Job Board

{"map_options":{"center_lat":"34.0739016","center_lng":"-117.3136547","zoom":19,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":true,"center_circle_fillcolor":"#8CAEF2","center_circle_fillopacity":".5","center_circle_strokecolor":"#8CAEF2","center_circle_strokeopacity":".5","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https:\/\/turnerstaffing.com\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","draggable":true,"scroll_wheel":"true","gesture":"auto","marker_default_icon":"https:\/\/turnerstaffing.com\/wp-content\/uploads\/2024\/03\/map-marker-solid.svg","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n<div class=\"fc-itemcontent-padding fc-infowindow-content\">\n<div class=\"fc-itemcontent-padding\">\n<div class=\"fc-item-title fc-item-primary-text-color\">{marker_title}<\/div>\n<div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\n                {marker_message}\n            <\/div>\n<\/p><\/div>\n<\/p><\/div>\n<\/div>\n","infowindow_geotags_setting":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    {post_title}\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    {post_excerpt}\r\n  <\/p>\r\n  <a href=\"{post_link}\" name=\"{post_title}\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","infowindow_skin":{"name":"kriday","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    &lt;div class=&quot;fc-itemcontent-padding fc-infowindow-content&quot;&gt;\r\n        &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n            &lt;div class=&quot;fc-item-title fc-item-primary-text-color&quot;&gt;{marker_title}&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {marker_message}\r\n            &lt;\/div&gt;\r\n        &lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n&lt;\/div&gt;"},"infowindow_post_skin":{"name":"kriday","type":"post","sourcecode":"&lt;div class=&quot;tsg-jb-popup-wrapper&quot;&gt;\r\n  &lt;h2 class=&quot;tsg-jb-popup-title&quot;&gt;\r\n    {post_title}\r\n  &lt;\/h2&gt;\r\n  &lt;p class=&quot;tsg-jb-popup-excerpt&quot;&gt;\r\n    {post_excerpt}\r\n  &lt;\/p&gt;\r\n  &lt;a href=&quot;{post_link}&quot; name=&quot;{post_title}&quot; class=&quot;tsg-jb-link&quot;&gt;&lt;button class=&quot;button&quot;&gt;View&lt;\/button&gt;&lt;\/a&gt;\r\n&lt;\/div&gt;"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"click","listing_infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":12,"infowindow_click_change_center":true,"full_screen_control":true,"search_control":true,"search_fields":["{post_title}","{post_content}","{%location_city%}","{%location_state_id%}","{%location_state_name%}"],"zoom_control":true,"map_type_control":false,"street_view_control":false,"locateme_control":false,"mobile_specific":true,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_height_mobile":"350","map_zoom_level_mobile":"5"},"ipads":{"map_height_mobile":"350","map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":true,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"10","url_filters":true,"doubleclickzoom":false,"current_post_only":false,"search_placeholder":"Search by role or location...","bound_map_after_filter":true,"display_reset_button":true,"map_reset_button_text":"Reset","height":"600"},"places":[{"source":"post","title":"General Laborer (Yardworker)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Laborer (Yardworker)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are seeking dependable and hardworking Yardworkers to support operations for a client in the metal recycling industry.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-laborer-yardworker\/\" name=\"General Laborer (Yardworker)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are seeking dependable and hardworking Yardworkers to support operations for a client in the metal recycling industry.&hellip;","address":"Colton, CA, USA","location":{"lat":"34.0739016","city":"Colton","state":"CA","country":"United States","lng":"-117.3136547","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-yardworker\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are seeking dependable and hardworking Yardworkers to support operations for a client in the metal recycling industry.&hellip;","post_content":"<h2>Position Overview<\/h2>\n<p>We are seeking dependable and hardworking Yardworkers to support operations for a client in the metal recycling industry. This position is responsible for assisting with general labor duties throughout an outdoor industrial recycling facility, including housekeeping, material handling, sorting, and customer service support.<\/p>\n<p>The ideal candidate is safety-focused, reliable, and comfortable working in a physically demanding outdoor environment.<\/p>\n<h2>Key Responsibilities<\/h2>\n<ul><li>Perform general labor duties throughout the recycling yard and facility<\/li><li>Sort, move, and organize recyclable materials safely and efficiently<\/li><li>Maintain cleanliness and housekeeping standards across the yard and work areas<\/li><li>Assist customers with unloading and directing materials<\/li><li>Support material handling operations using hand tools and equipment<\/li><li>Follow all company safety procedures and site rules<\/li><li>Work collaboratively with supervisors and team members to maintain production flow<\/li><li>Complete additional duties as assigned<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>Previous general labor, warehouse, recycling, or industrial experience preferred<\/li><li>Strong work ethic and ability to work in outdoor conditions year-round<\/li><li>Ability to stand for extended periods of time<\/li><li>Ability to bend, kneel, and lift up to approximately 50 pounds regularly<\/li><li>Good communication and customer service skills<\/li><li>Ability to work safely in an industrial environment<\/li><li>Bilingual English\/Spanish is a plus<\/li><\/ul>\n<h2>Physical Requirements<\/h2>\n<ul><li>Prolonged standing and walking throughout the workday<\/li><li>Frequent lifting, carrying, bending, and kneeling<\/li><li>Ability to work outdoors in varying weather conditions<\/li><li>Ability to safely perform physical labor in an active industrial setting<\/li><\/ul>","post_title":"General Laborer (Yardworker)","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer-yardworker\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Colton","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Colton, CA","%education%":"Unspecified","%department%":"TSG","%description%":"<h2>Position Overview<\/h2>\n<p>We are seeking dependable and hardworking Yardworkers to support operations for a client in the metal recycling industry. This position is responsible for assisting with general labor duties throughout an outdoor industrial recycling facility, including housekeeping, material handling, sorting, and customer service support.<\/p>\n<p>The ideal candidate is safety-focused, reliable, and comfortable working in a physically demanding outdoor environment.<\/p>\n<h2>Key Responsibilities<\/h2>\n<ul><li>Perform general labor duties throughout the recycling yard and facility<\/li><li>Sort, move, and organize recyclable materials safely and efficiently<\/li><li>Maintain cleanliness and housekeeping standards across the yard and work areas<\/li><li>Assist customers with unloading and directing materials<\/li><li>Support material handling operations using hand tools and equipment<\/li><li>Follow all company safety procedures and site rules<\/li><li>Work collaboratively with supervisors and team members to maintain production flow<\/li><li>Complete additional duties as assigned<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>Previous general labor, warehouse, recycling, or industrial experience preferred<\/li><li>Strong work ethic and ability to work in outdoor conditions year-round<\/li><li>Ability to stand for extended periods of time<\/li><li>Ability to bend, kneel, and lift up to approximately 50 pounds regularly<\/li><li>Good communication and customer service skills<\/li><li>Ability to work safely in an industrial environment<\/li><li>Bilingual English\/Spanish is a plus<\/li><\/ul>\n<h2>Physical Requirements<\/h2>\n<ul><li>Prolonged standing and walking throughout the workday<\/li><li>Frequent lifting, carrying, bending, and kneeling<\/li><li>Ability to work outdoors in varying weather conditions<\/li><li>Ability to safely perform physical labor in an active industrial setting<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3c4e1560b9c7-general-laborer-yardworker","%breezy_id%":"3c4e1560b9c7","%breezy_friendly_id%":"3c4e1560b9c7-general-laborer-yardworker","%breezy_created_date%":"2026-06-10T01:19:17.808Z","%breezy_updated_date%":"2026-06-10T01:25:25.410Z","%_wpgmp_location_city%":"Colton","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Colton, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0739016","%_wpgmp_metabox_longitude%":"-117.3136547","%rank_math_internal_links_processed%":"1"}},"id":3770,"infowindow_disable":false},{"source":"post","title":"Asphalt Plant Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Asphalt Plant Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Summary We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/asphalt-plant-superintendent-2\/\" name=\"Asphalt Plant Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Summary We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients&hellip;","address":"Redmond, OR, USA","location":{"lat":"44.2726203","city":"Redmond","state":"OR","country":"United States","lng":"-121.1739212","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/asphalt-plant-superintendent-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Summary We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients&hellip;","post_content":"<p>Position Summary<\/p>\n<p>We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients in Central and Eastern Oregon. This position is responsible for overseeing daily asphalt plant operations, production schedules, plant maintenance, repairs, and safety compliance. The ideal candidate will possess strong leadership skills, extensive knowledge of asphalt plant operations, and the ability to manage personnel, equipment, and plant performance efficiently and safely.<\/p>\n<p>Essential Duties and Responsibilities<\/p>\n<p>\u2022\tTroubleshoot plant operational issues, electrical systems, PLC controls, burners, and material flow systems<\/p>\n<p>\u2022\tSupervise and coordinate asphalt plant operations and personnel<\/p>\n<p>\u2022\tManage daily production schedules to meet project and customer demands<\/p>\n<p>\u2022\tMonitor asphalt mix production for compliance with job specifications and quality standards<\/p>\n<p>\u2022\tCoordinate plant maintenance, repairs, and preventative maintenance programs<\/p>\n<p>\u2022\tEnsure compliance with OSHA, MSHA, DEQ, environmental, and company safety regulations<\/p>\n<p>\u2022\tCoordinate aggregate, oil, and liquid AC inventory levels and deliveries with plant operators<\/p>\n<p>\u2022\tCommunicate and work effectively with paving crews, truck dispatch, quality control staff, and management teams<\/p>\n<p>\u2022\tMaintain accurate production reports, inventory records, maintenance documentation, and parts inventory<\/p>\n<p>\u2022\tTrain, mentor, and evaluate plant personnel<\/p>\n<p>\u2022\tEnsure proper housekeeping and organization of the plant site<\/p>\n<p>Qualifications<\/p>\n<p>\u2022\tMinimum 5 years of asphalt plant operations experience preferred<\/p>\n<p>\u2022\tMechanical and troubleshooting experience with asphalt plant equipment required<\/p>\n<p>\u2022\tPrevious supervisory or management experience preferred<\/p>\n<p>\u2022\tExperience with plant automation systems and PLC controls preferred<\/p>\n<p>\u2022\tUnderstanding of OSHA, MSHA, and environmental compliance requirements<\/p>\n<p>\u2022\tAbility to work flexible hours, including nights and weekends during paving season<\/p>\n<p>\u2022\tStrong leadership, organizational, and communication skills<\/p>\n<p>Benefits<\/p>\n<p>\u2022\tParticipation in company profit sharing program<\/p>\n<p>\u2022\tCompany-paid health and dental insurance (employee contribution may apply)<\/p>\n<p>\u2022\tPaid time off:<\/p>\n<p>o\tYears 1\u20133: 2 weeks<\/p>\n<p>o\tYears 4\u20135: 3 weeks<\/p>\n<p>o\tYears 6+: 4 weeks<\/p>\n<p>\u2022\t401(k) with employee deferral, matching, and profit sharing opportunities<\/p>\n<p>\u2022\tPaid holidays:<\/p>\n<p>o\tTwo paid holidays after the first year of employment, increasing by two per year up to a maximum of six paid holidays<\/p>\n<p>\u2022\tCompany vehicle<\/p>\n<p>\u2022\tCompany cell phone<\/p>\n<p>\u2022\tCompany laptop<\/p>","post_title":"Asphalt Plant Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/asphalt-plant-superintendent-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Redmond","%location_state_id%":"OR","%location_state_name%":"Oregon","%location_city_state%":"Redmond, OR","%education%":"Unspecified","%department%":"TSG","%description%":"<p>Position Summary<\/p>\n<p>We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients in Central and Eastern Oregon. This position is responsible for overseeing daily asphalt plant operations, production schedules, plant maintenance, repairs, and safety compliance. The ideal candidate will possess strong leadership skills, extensive knowledge of asphalt plant operations, and the ability to manage personnel, equipment, and plant performance efficiently and safely.<\/p>\n<p>Essential Duties and Responsibilities<\/p>\n<p>\u2022\tTroubleshoot plant operational issues, electrical systems, PLC controls, burners, and material flow systems<\/p>\n<p>\u2022\tSupervise and coordinate asphalt plant operations and personnel<\/p>\n<p>\u2022\tManage daily production schedules to meet project and customer demands<\/p>\n<p>\u2022\tMonitor asphalt mix production for compliance with job specifications and quality standards<\/p>\n<p>\u2022\tCoordinate plant maintenance, repairs, and preventative maintenance programs<\/p>\n<p>\u2022\tEnsure compliance with OSHA, MSHA, DEQ, environmental, and company safety regulations<\/p>\n<p>\u2022\tCoordinate aggregate, oil, and liquid AC inventory levels and deliveries with plant operators<\/p>\n<p>\u2022\tCommunicate and work effectively with paving crews, truck dispatch, quality control staff, and management teams<\/p>\n<p>\u2022\tMaintain accurate production reports, inventory records, maintenance documentation, and parts inventory<\/p>\n<p>\u2022\tTrain, mentor, and evaluate plant personnel<\/p>\n<p>\u2022\tEnsure proper housekeeping and organization of the plant site<\/p>\n<p>Qualifications<\/p>\n<p>\u2022\tMinimum 5 years of asphalt plant operations experience preferred<\/p>\n<p>\u2022\tMechanical and troubleshooting experience with asphalt plant equipment required<\/p>\n<p>\u2022\tPrevious supervisory or management experience preferred<\/p>\n<p>\u2022\tExperience with plant automation systems and PLC controls preferred<\/p>\n<p>\u2022\tUnderstanding of OSHA, MSHA, and environmental compliance requirements<\/p>\n<p>\u2022\tAbility to work flexible hours, including nights and weekends during paving season<\/p>\n<p>\u2022\tStrong leadership, organizational, and communication skills<\/p>\n<p>Benefits<\/p>\n<p>\u2022\tParticipation in company profit sharing program<\/p>\n<p>\u2022\tCompany-paid health and dental insurance (employee contribution may apply)<\/p>\n<p>\u2022\tPaid time off:<\/p>\n<p>o\tYears 1\u20133: 2 weeks<\/p>\n<p>o\tYears 4\u20135: 3 weeks<\/p>\n<p>o\tYears 6+: 4 weeks<\/p>\n<p>\u2022\t401(k) with employee deferral, matching, and profit sharing opportunities<\/p>\n<p>\u2022\tPaid holidays:<\/p>\n<p>o\tTwo paid holidays after the first year of employment, increasing by two per year up to a maximum of six paid holidays<\/p>\n<p>\u2022\tCompany vehicle<\/p>\n<p>\u2022\tCompany cell phone<\/p>\n<p>\u2022\tCompany laptop<\/p>","%category%":"Management","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/81c3a2b6da4f-asphalt-plant-superintendent","%breezy_id%":"81c3a2b6da4f","%breezy_friendly_id%":"81c3a2b6da4f-asphalt-plant-superintendent","%breezy_created_date%":"2026-06-09T14:30:30.465Z","%breezy_updated_date%":"2026-06-09T14:30:38.568Z","%_wpgmp_location_city%":"Redmond","%_wpgmp_location_state%":"OR","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Redmond, OR, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"44.2726203","%_wpgmp_metabox_longitude%":"-121.1739212","%rank_math_internal_links_processed%":"1"}},"id":3768,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","address":"Greencastle, IN, USA","location":{"lat":"39.6439943","city":"Greencastle","state":"IN","country":"United States","lng":"-86.8645066","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/","zoom":19,"extra_fields":{"post_excerpt":"Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","post_content":"<p><strong><u>Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <br><\/p>\n\n<p>We are looking for a dynamic and talented mining Haul Truck Driver for our mining services client for a temporary project opportunity in Greencastle, IN.<\/p>\n<p>We are seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<br><\/p>\n\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><br><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Temporary","%experience%":"Associate","%location_country%":"United States","%location_city%":"Greencastle","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Greencastle, IN","%education%":"Unspecified","%department%":"TSG","%description%":"<p><strong><u>Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <br><\/p>\n\n<p>We are looking for a dynamic and talented mining Haul Truck Driver for our mining services client for a temporary project opportunity in Greencastle, IN.<\/p>\n<p>We are seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<br><\/p>\n\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><br><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/499cbabe10a8-haul-truck-driver","%breezy_id%":"499cbabe10a8","%breezy_friendly_id%":"499cbabe10a8-haul-truck-driver","%breezy_created_date%":"2026-06-09T14:22:31.216Z","%breezy_updated_date%":"2026-06-09T14:23:57.289Z","%_wpgmp_location_city%":"Greencastle","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Greencastle, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.6439943","%_wpgmp_metabox_longitude%":"-86.8645066","%rank_math_internal_links_processed%":"1"}},"id":3767,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are actively seeking a Heavy Equipment Operator to work with us in the Ann Arbor, MI area. Essential Duties&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are actively seeking a Heavy Equipment Operator to work with us in the Ann Arbor, MI area. Essential Duties&hellip;","address":"Ann Arbor, MI, USA","location":{"lat":"42.2808256","city":"Ann Arbor","state":"MI","country":"United States","lng":"-83.7430378","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"We are actively seeking a Heavy Equipment Operator to work with us in the Ann Arbor, MI area. Essential Duties&hellip;","post_content":"<p>We are actively seeking a Heavy Equipment Operator to work with us in the Ann Arbor, MI area.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors and teammates<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Participate in necessary training sessions.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators<\/li><li>GPS System experience required<\/li><li>Ability to read and understand grade stakes.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Ann Arbor","%location_state_id%":"MI","%location_state_name%":"Michigan","%location_city_state%":"Ann Arbor, MI","%education%":"Unspecified","%department%":"TSG","%description%":"<p>We are actively seeking a Heavy Equipment Operator to work with us in the Ann Arbor, MI area.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors and teammates<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Participate in necessary training sessions.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators<\/li><li>GPS System experience required<\/li><li>Ability to read and understand grade stakes.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/c18fc35f650e-heavy-equipment-operator","%breezy_id%":"c18fc35f650e","%breezy_friendly_id%":"c18fc35f650e-heavy-equipment-operator","%breezy_created_date%":"2026-06-09T13:14:27.712Z","%breezy_updated_date%":"2026-06-09T13:15:01.192Z","%_wpgmp_location_city%":"Ann Arbor","%_wpgmp_location_state%":"MI","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ann Arbor, MI, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.2808256","%_wpgmp_metabox_longitude%":"-83.7430378","%rank_math_internal_links_processed%":"1"}},"id":3766,"infowindow_disable":false},{"source":"post","title":"Field Service Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the North&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-3\/\" name=\"Field Service Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the North&hellip;","address":"Jamestown, ND, USA","location":{"lat":"46.9105438","city":"Jamestown","state":"ND","country":"United States","lng":"-98.7084357","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-3\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the North&hellip;","post_content":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the North Dakota. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","post_title":"Field Service Technician","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Jamestown","%location_state_id%":"ND","%location_state_name%":"North Dakota","%location_city_state%":"Jamestown, ND","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the North Dakota. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/1ca33288b1b4-field-service-technician","%breezy_id%":"1ca33288b1b4","%breezy_friendly_id%":"1ca33288b1b4-field-service-technician","%breezy_created_date%":"2026-06-07T12:39:28.471Z","%breezy_updated_date%":"2026-06-07T12:39:38.357Z","%_wpgmp_location_city%":"Jamestown","%_wpgmp_location_state%":"ND","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Jamestown, ND, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"46.9105438","%_wpgmp_metabox_longitude%":"-98.7084357","%rank_math_internal_links_processed%":"1"}},"id":3755,"infowindow_disable":false},{"source":"post","title":"Field Service Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the North&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-2\/\" name=\"Field Service Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the North&hellip;","address":"Grand Forks, ND, USA","location":{"lat":"47.9252568","city":"Grand Forks","state":"ND","country":"United States","lng":"-97.0328547","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the North&hellip;","post_content":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the North Dakota. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","post_title":"Field Service Technician","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Grand Forks","%location_state_id%":"ND","%location_state_name%":"North Dakota","%location_city_state%":"Grand Forks, ND","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the North Dakota. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ce1dfa55b3f5-field-service-technician","%breezy_id%":"ce1dfa55b3f5","%breezy_friendly_id%":"ce1dfa55b3f5-field-service-technician","%breezy_created_date%":"2026-06-07T12:38:31.375Z","%breezy_updated_date%":"2026-06-07T12:38:42.002Z","%_wpgmp_location_city%":"Grand Forks","%_wpgmp_location_state%":"ND","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Grand Forks, ND, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"47.9252568","%_wpgmp_metabox_longitude%":"-97.0328547","%rank_math_internal_links_processed%":"1"}},"id":3754,"infowindow_disable":false},{"source":"post","title":"Field Service Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the North&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician\/\" name=\"Field Service Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the North&hellip;","address":"Bismarck, ND, USA","location":{"lat":"46.8041643","city":"Bismarck","state":"ND","country":"United States","lng":"-100.7877616","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the North&hellip;","post_content":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the North Dakota. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","post_title":"Field Service Technician","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bismarck","%location_state_id%":"ND","%location_state_name%":"North Dakota","%location_city_state%":"Bismarck, ND","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the North Dakota. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/38d51a713e20-field-service-technician","%breezy_id%":"38d51a713e20","%breezy_friendly_id%":"38d51a713e20-field-service-technician","%breezy_created_date%":"2026-06-07T12:36:00.336Z","%breezy_updated_date%":"2026-06-07T12:36:19.667Z","%_wpgmp_location_city%":"Bismarck","%_wpgmp_location_state%":"ND","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bismarck, ND, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"46.8041643","%_wpgmp_metabox_longitude%":"-100.7877616","%rank_math_internal_links_processed%":"1"}},"id":3753,"infowindow_disable":false},{"source":"post","title":"Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Explore Alaska. Advance a Major Gold Project. 40\/20 Rotation | Camp-Based Position | Seasonal Full-Time Looking for more than another&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist-2\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Explore Alaska. Advance a Major Gold Project. 40\/20 Rotation | Camp-Based Position | Seasonal Full-Time Looking for more than another&hellip;","address":"Fairbanks, AKUnited States","location":{"lat":"64.8400511","city":"Fairbanks","state":"AK","country":"United States","lng":"-147.7199756","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist-2\/","zoom":19,"extra_fields":{"post_excerpt":"Explore Alaska. Advance a Major Gold Project. 40\/20 Rotation | Camp-Based Position | Seasonal Full-Time Looking for more than another&hellip;","post_content":"<p>Explore Alaska. Advance a Major Gold Project.<\/p><p><strong>40\/20 Rotation | Camp-Based Position | Seasonal Full-Time<\/strong><\/p><p>Looking for more than another core logging job?<\/p><p>Spend your season working in Alaska's interior on a large-scale gold exploration project while gaining valuable hands-on experience in drill core logging, geological interpretation, and exploration fieldwork. This is an opportunity to be part of an active exploration program supporting the advancement of a significant gold deposit while experiencing the unique challenges and rewards of remote Alaskan field life.<\/p><p>From long summer days beneath the midnight sun to winter operations in one of the world's premier mining jurisdictions, this role offers the chance to develop your technical geology skills while working alongside an experienced exploration team in a truly unique setting.<\/p><p>Whether you're an early-career geologist looking to build exploration experience or a field geologist seeking your next adventure, this position offers meaningful project exposure, rotational work schedules, and the opportunity to live and work in one of North America's most geologically prospective regions.<\/p><p><strong>Why This Opportunity?<\/strong><\/p><ul><li><p>Work on a major gold exploration project advancing toward Pre-Feasibility Study.<\/p><\/li><li><p>Gain hands-on experience logging and interpreting mineralized drill core.<\/p><\/li><li><p>Work alongside experienced exploration geologists and technical professionals.<\/p><\/li><li><p>Experience life in a remote Alaskan exploration camp.<\/p><\/li><li><p>Enjoy a rotational schedule with extended time off between work periods.<\/p><\/li><li><p>Explore Alaska's world-class outdoor recreation opportunities during your time off.<\/p><\/li><li><p>Build experience that can accelerate your career in mineral exploration and mining.<\/p><\/li><\/ul><p><strong>Position Summary<\/strong><\/p><p>The Geologist will support an active exploration drilling program through core logging, sampling, geological data collection, and field support activities. Working under the supervision of senior geology staff, successful candidates will contribute to the collection and interpretation of geological information used to advance project development and resource growth.<\/p><p>Training on project-specific logging procedures and workflows will be provided.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li><p>Log drill core for lithology, alteration, mineralization, and structural features.<\/p><\/li><li><p>Assess and document geological characteristics of a gold mineralized system.<\/p><\/li><li><p>Mark drill core for sampling and maintain sample integrity through established QA\/QC procedures.<\/p><\/li><li><p>Assist with geotechnical logging including recovery, RQD, and magnetic susceptibility measurements.<\/p><\/li><li><p>Collect and record structural measurements from oriented core when required.<\/p><\/li><li><p>Photograph and document drill core.<\/p><\/li><li><p>Coordinate with sampling and core-cutting personnel to maintain efficient workflows.<\/p><\/li><li><p>Visit active drill sites to collect field data and support exploration activities.<\/p><\/li><li><p>Participate in geological mapping, prospecting, and geochemical sampling programs as required.<\/p><\/li><li><p>Maintain accurate geological records and databases.<\/p><\/li><li><p>Follow all safety, environmental, and operational procedures.<\/p><\/li><\/ul><p><strong>Required Qualifications<\/strong><\/p><ul><li><p>Bachelor's degree in Geology, Earth Sciences, or a related discipline.<\/p><\/li><li><p>Minimum 2 years of experience in mineral exploration, mining, or related geological work.<\/p><\/li><li><p>Strong understanding of igneous, metamorphic, and structural geology.<\/p><\/li><li><p>Ability to identify rock types, alteration assemblages, and mineralization styles in drill core and hand specimen.<\/p><\/li><li><p>Experience with geological logging and database software.<\/p><\/li><li><p>Valid driver's license and ability to work safely in remote environments.<\/p><p><\/p><\/li><\/ul><p><strong>Preferred Qualifications<\/strong><\/p><ul><li><p>Previous core logging experience in exploration or mining environments.<\/p><\/li><li><p>Experience with gold deposits, intrusion-related gold systems, or porphyry-style mineralization.<\/p><\/li><li><p>Familiarity with oriented core techniques and structural geology.<\/p><\/li><li><p>Current First Aid certification.<\/p><\/li><li><p>Experience operating in remote field environments.<\/p><\/li><\/ul><p><strong>Camp Life<\/strong><\/p><p>Camp accommodations include:<\/p><ul><li><p>Private heated accommodations<\/p><\/li><li><p>Starlink internet access<\/p><\/li><li><p>Laundry facilities<\/p><\/li><li><p>Showers and flush toilets<\/p><\/li><li><p>All meals provided<\/p><\/li><li><p>Transportation support within the project area<\/p><\/li><\/ul><p><strong>Schedule<\/strong><\/p><ul><li><p>Approximately 40 days on \/ 20 days off<\/p><\/li><li><p>Full-time rotational schedule<\/p><\/li><li><p>Project expected to continue through year-end 2026 with potential for extension<\/p><\/li><\/ul><p><strong>Work Authorization<\/strong><\/p><p>Candidates must be legally authorized to work in the United States without current or future visa sponsorship.<\/p><p>If you're looking for an opportunity that combines professional growth, hands-on exploration experience, and the adventure of working in remote Alaska, we'd like to hear from you.<\/p>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Fairbanks","%location_state_id%":"AK","%location_city_state%":"Fairbanks, AK","%description%":"<p>Explore Alaska. Advance a Major Gold Project.<\/p><p><strong>40\/20 Rotation | Camp-Based Position | Seasonal Full-Time<\/strong><\/p><p>Looking for more than another core logging job?<\/p><p>Spend your season working in Alaska's interior on a large-scale gold exploration project while gaining valuable hands-on experience in drill core logging, geological interpretation, and exploration fieldwork. This is an opportunity to be part of an active exploration program supporting the advancement of a significant gold deposit while experiencing the unique challenges and rewards of remote Alaskan field life.<\/p><p>From long summer days beneath the midnight sun to winter operations in one of the world's premier mining jurisdictions, this role offers the chance to develop your technical geology skills while working alongside an experienced exploration team in a truly unique setting.<\/p><p>Whether you're an early-career geologist looking to build exploration experience or a field geologist seeking your next adventure, this position offers meaningful project exposure, rotational work schedules, and the opportunity to live and work in one of North America's most geologically prospective regions.<\/p><p><strong>Why This Opportunity?<\/strong><\/p><ul><li><p>Work on a major gold exploration project advancing toward Pre-Feasibility Study.<\/p><\/li><li><p>Gain hands-on experience logging and interpreting mineralized drill core.<\/p><\/li><li><p>Work alongside experienced exploration geologists and technical professionals.<\/p><\/li><li><p>Experience life in a remote Alaskan exploration camp.<\/p><\/li><li><p>Enjoy a rotational schedule with extended time off between work periods.<\/p><\/li><li><p>Explore Alaska's world-class outdoor recreation opportunities during your time off.<\/p><\/li><li><p>Build experience that can accelerate your career in mineral exploration and mining.<\/p><\/li><\/ul><p><strong>Position Summary<\/strong><\/p><p>The Geologist will support an active exploration drilling program through core logging, sampling, geological data collection, and field support activities. Working under the supervision of senior geology staff, successful candidates will contribute to the collection and interpretation of geological information used to advance project development and resource growth.<\/p><p>Training on project-specific logging procedures and workflows will be provided.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li><p>Log drill core for lithology, alteration, mineralization, and structural features.<\/p><\/li><li><p>Assess and document geological characteristics of a gold mineralized system.<\/p><\/li><li><p>Mark drill core for sampling and maintain sample integrity through established QA\/QC procedures.<\/p><\/li><li><p>Assist with geotechnical logging including recovery, RQD, and magnetic susceptibility measurements.<\/p><\/li><li><p>Collect and record structural measurements from oriented core when required.<\/p><\/li><li><p>Photograph and document drill core.<\/p><\/li><li><p>Coordinate with sampling and core-cutting personnel to maintain efficient workflows.<\/p><\/li><li><p>Visit active drill sites to collect field data and support exploration activities.<\/p><\/li><li><p>Participate in geological mapping, prospecting, and geochemical sampling programs as required.<\/p><\/li><li><p>Maintain accurate geological records and databases.<\/p><\/li><li><p>Follow all safety, environmental, and operational procedures.<\/p><\/li><\/ul><p><strong>Required Qualifications<\/strong><\/p><ul><li><p>Bachelor's degree in Geology, Earth Sciences, or a related discipline.<\/p><\/li><li><p>Minimum 2 years of experience in mineral exploration, mining, or related geological work.<\/p><\/li><li><p>Strong understanding of igneous, metamorphic, and structural geology.<\/p><\/li><li><p>Ability to identify rock types, alteration assemblages, and mineralization styles in drill core and hand specimen.<\/p><\/li><li><p>Experience with geological logging and database software.<\/p><\/li><li><p>Valid driver's license and ability to work safely in remote environments.<\/p><p><\/p><\/li><\/ul><p><strong>Preferred Qualifications<\/strong><\/p><ul><li><p>Previous core logging experience in exploration or mining environments.<\/p><\/li><li><p>Experience with gold deposits, intrusion-related gold systems, or porphyry-style mineralization.<\/p><\/li><li><p>Familiarity with oriented core techniques and structural geology.<\/p><\/li><li><p>Current First Aid certification.<\/p><\/li><li><p>Experience operating in remote field environments.<\/p><\/li><\/ul><p><strong>Camp Life<\/strong><\/p><p>Camp accommodations include:<\/p><ul><li><p>Private heated accommodations<\/p><\/li><li><p>Starlink internet access<\/p><\/li><li><p>Laundry facilities<\/p><\/li><li><p>Showers and flush toilets<\/p><\/li><li><p>All meals provided<\/p><\/li><li><p>Transportation support within the project area<\/p><\/li><\/ul><p><strong>Schedule<\/strong><\/p><ul><li><p>Approximately 40 days on \/ 20 days off<\/p><\/li><li><p>Full-time rotational schedule<\/p><\/li><li><p>Project expected to continue through year-end 2026 with potential for extension<\/p><\/li><\/ul><p><strong>Work Authorization<\/strong><\/p><p>Candidates must be legally authorized to work in the United States without current or future visa sponsorship.<\/p><p>If you're looking for an opportunity that combines professional growth, hands-on exploration experience, and the adventure of working in remote Alaska, we'd like to hear from you.<\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/8qkj6w9fhmk4rsoiy6u3of8ape","%crelate_id%":"8qkj6w9fhmk4rsoiy6u3of8ape","%crelate_created_date%":"2026-06-05T10:07:15.12Z","%crelate_updated_date%":"2026-06-11T11:09:53.85Z","%_wpgmp_location_city%":"Fairbanks","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairbanks, AKUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"64.8400511","%_wpgmp_metabox_longitude%":"-147.7199756","%rank_math_internal_links_processed%":"1"}},"id":3751,"infowindow_disable":false},{"source":"post","title":"Electrical Construction Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrical Construction Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Electrical Construction Superintendent is a fixed-term role supporting a major construction restart program with an anticipated duration of 12&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrical-construction-superintendent\/\" name=\"Electrical Construction Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Electrical Construction Superintendent is a fixed-term role supporting a major construction restart program with an anticipated duration of 12&hellip;","address":"Republic, WAUnited States","location":{"lat":"48.6482183","city":"Republic","state":"WA","country":"United States","lng":"-118.7378067","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrical-construction-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"The Electrical Construction Superintendent is a fixed-term role supporting a major construction restart program with an anticipated duration of 12&hellip;","post_content":"<p>The Electrical Construction Superintendent is a fixed-term role supporting a major construction restart program with an anticipated duration of 12 months. Reporting directly to the Construction Manager, this individual will serve as a key member of the construction management team and will oversee all day-to-day electrical construction activities on site.<\/p><p>This assignment has the potential to develop into a long-term opportunity for the right candidate.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Oversee and coordinate electrical installations and systems throughout the project, ensuring all work is completed safely, on schedule, within budget, and in compliance with quality standards. <\/li><li>Review and enforce adherence to project plans, drawings, specifications, and construction standards. <\/li><li>Partner with field engineering personnel to inspect electrical work and verify compliance with project requirements and industry standards. <\/li><li>Identify and address construction deficiencies or deviations to minimize delays and maintain productivity. <\/li><li>Review electrical designs, drawings, and specifications and provide constructability feedback. <\/li><li>Maintain and submit daily construction reports documenting progress, labor hours, equipment usage, weather conditions, permits, inspections, and other project records. <\/li><li>Collaborate with engineering and design teams to resolve technical issues and support successful project execution. <\/li><li>Serve as a liaison between contractors, subcontractors, project stakeholders, and the construction management team. <\/li><li>Provide direction, oversight, and coordination to contractors and site personnel. <\/li><li>Participate in daily and weekly planning and coordination meetings. <\/li><li>Communicate project status, risks, and challenges to the Construction Management Team. <\/li><li>Perform other duties as assigned. <\/li><\/ul><p><strong>Qualifications<\/strong><\/p><ul><li>Bachelor's degree in Electrical Engineering, Construction Management, or a related field preferred; equivalent experience will be considered. <\/li><li>Minimum of four (4) years of electrical construction supervision experience, preferably within mining, industrial, or heavy construction environments. <\/li><li>Demonstrated experience overseeing large-scale electrical installations and infrastructure projects. <\/li><li>Strong knowledge of electrical construction methods, materials, equipment, and industry best practices. <\/li><li>Familiarity with mine safety regulations (MSHA) and environmental compliance standards. <\/li><li>Excellent communication, leadership, analytical, and problem-solving skills. <\/li><li>Valid driver's license. <\/li><li>Must be authorized to work in the United States without current or future visa sponsorship. <\/li><\/ul><p><strong>Health, Safety &amp; Environmental Commitment<\/strong><\/p><ul><li>Demonstrate a strong commitment to workplace safety and environmental stewardship. <\/li><li>Adhere to all site-specific safety policies, procedures, and regulatory requirements. <\/li><li>Wear required personal protective equipment (PPE) while in operational environments. <\/li><li>Identify, correct, and report unsafe conditions or behaviors. <\/li><li>Follow established operating procedures and safety protocols at all times. <\/li><\/ul>","post_title":"Electrical Construction Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/electrical-construction-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Republic","%location_state_id%":"WA","%location_city_state%":"Republic, WA","%description%":"<p>The Electrical Construction Superintendent is a fixed-term role supporting a major construction restart program with an anticipated duration of 12 months. Reporting directly to the Construction Manager, this individual will serve as a key member of the construction management team and will oversee all day-to-day electrical construction activities on site.<\/p><p>This assignment has the potential to develop into a long-term opportunity for the right candidate.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Oversee and coordinate electrical installations and systems throughout the project, ensuring all work is completed safely, on schedule, within budget, and in compliance with quality standards. <\/li><li>Review and enforce adherence to project plans, drawings, specifications, and construction standards. <\/li><li>Partner with field engineering personnel to inspect electrical work and verify compliance with project requirements and industry standards. <\/li><li>Identify and address construction deficiencies or deviations to minimize delays and maintain productivity. <\/li><li>Review electrical designs, drawings, and specifications and provide constructability feedback. <\/li><li>Maintain and submit daily construction reports documenting progress, labor hours, equipment usage, weather conditions, permits, inspections, and other project records. <\/li><li>Collaborate with engineering and design teams to resolve technical issues and support successful project execution. <\/li><li>Serve as a liaison between contractors, subcontractors, project stakeholders, and the construction management team. <\/li><li>Provide direction, oversight, and coordination to contractors and site personnel. <\/li><li>Participate in daily and weekly planning and coordination meetings. <\/li><li>Communicate project status, risks, and challenges to the Construction Management Team. <\/li><li>Perform other duties as assigned. <\/li><\/ul><p><strong>Qualifications<\/strong><\/p><ul><li>Bachelor's degree in Electrical Engineering, Construction Management, or a related field preferred; equivalent experience will be considered. <\/li><li>Minimum of four (4) years of electrical construction supervision experience, preferably within mining, industrial, or heavy construction environments. <\/li><li>Demonstrated experience overseeing large-scale electrical installations and infrastructure projects. <\/li><li>Strong knowledge of electrical construction methods, materials, equipment, and industry best practices. <\/li><li>Familiarity with mine safety regulations (MSHA) and environmental compliance standards. <\/li><li>Excellent communication, leadership, analytical, and problem-solving skills. <\/li><li>Valid driver's license. <\/li><li>Must be authorized to work in the United States without current or future visa sponsorship. <\/li><\/ul><p><strong>Health, Safety &amp; Environmental Commitment<\/strong><\/p><ul><li>Demonstrate a strong commitment to workplace safety and environmental stewardship. <\/li><li>Adhere to all site-specific safety policies, procedures, and regulatory requirements. <\/li><li>Wear required personal protective equipment (PPE) while in operational environments. <\/li><li>Identify, correct, and report unsafe conditions or behaviors. <\/li><li>Follow established operating procedures and safety protocols at all times. <\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/rjqmuuza9rmn6nttp5a1758hdo","%crelate_id%":"rjqmuuza9rmn6nttp5a1758hdo","%crelate_created_date%":"2026-06-01T12:35:11.23Z","%crelate_updated_date%":"2026-06-02T07:43:29.4Z","%_wpgmp_location_city%":"Republic","%_wpgmp_location_state%":"WA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Republic, WAUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"48.6482183","%_wpgmp_metabox_longitude%":"-118.7378067","%rank_math_internal_links_processed%":"1"}},"id":3739,"infowindow_disable":false},{"source":"post","title":"Project Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking an experienced Exploration Project Geologist for a 6-month project assignment with the possibility of extension.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-geologist\/\" name=\"Project Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking an experienced Exploration Project Geologist for a 6-month project assignment with the possibility of extension.&hellip;","address":"Kirkland, AZUnited States","location":{"lat":"34.4316071","city":"Kirkland","state":"AZ","country":"United States","lng":"-112.7435171","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-geologist\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking an experienced Exploration Project Geologist for a 6-month project assignment with the possibility of extension.&hellip;","post_content":"<p>Turner Staffing Group is seeking an experienced <strong>Exploration Project Geologist<\/strong> for a 6-month project assignment with the possibility of extension. This role supports exploration drilling programs and field operations, combining technical geology expertise with project coordination, contractor management, and exploration program oversight.<\/p><p>The ideal candidate will have hands-on core logging experience and a proven track record supporting or managing exploration drilling programs in active field environments. This position requires regular travel to project sites throughout Arizona and close collaboration with geologists, drilling contractors, and project stakeholders.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Coordinate exploration drilling activities and day-to-day field operations. <\/li><li>Ensure equipment, field supplies, and materials arrive on schedule. <\/li><li>Manage field schedules and drill program work plans. <\/li><li>Monitor project progress including drilling, logging, sampling, scanning, and assay workflows. <\/li><li>Oversee contractor and vendor performance. <\/li><li>Support compliance with health, safety, environmental, and regulatory requirements. <\/li><li>Troubleshoot operational challenges that impact schedules, budgets, or project objectives. <\/li><li>Identify project risks and develop mitigation strategies. <\/li><li>Provide regular project updates and status reports to stakeholders. <\/li><li>Support the review and interpretation of exploration data and results. <\/li><li>Collaborate with technical teams to evaluate findings and recommend next phases of work. <\/li><li>Balance operational priorities with technical exploration objectives. <\/li><\/ul><p><strong>Typical Responsibilities<\/strong><\/p><p>A typical day may include:<\/p><ul><li>Reviewing drilling progress and inspecting core retrieval activities. <\/li><li>Coordinating with drilling contractors and resolving field issues. <\/li><li>Updating project schedules, trackers, and reporting tools. <\/li><li>Meeting with geologists and project stakeholders to review exploration results. <\/li><li>Reporting project risks, milestones, and recommendations. <\/li><li>Supporting ongoing program adjustments based on new geological information. <\/li><\/ul><p><strong>Required Qualifications<\/strong><\/p><ul><li>Bachelor's degree in Geology, Geoscience, Geological Engineering, or a related field. <\/li><li>3-7 years of mineral exploration experience. <\/li><li>Hands-on experience logging drill core and supporting exploration drilling programs. <\/li><li>Experience coordinating field operations, contractors, and exploration activities. <\/li><li>Strong understanding of drilling, sampling, and exploration workflows. <\/li><li>Ability to work independently in remote field environments. <\/li><li>Excellent organizational, communication, and problem-solving skills. <\/li><li>Proficiency with Microsoft Office and standard geological data management systems. <\/li><li>Ability to travel regularly to project sites throughout Arizona. <\/li><\/ul><p><strong>Preferred Qualifications<\/strong><\/p><ul><li>Experience managing exploration drill programs. <\/li><li>Experience working with multiple contractors and vendors. <\/li><li>Knowledge of exploration project budgeting and scheduling. <\/li><li>Familiarity with safety and environmental compliance requirements within mining operations. <\/li><\/ul><p><strong>What We're Looking For<\/strong><\/p><ul><li>Strong communicator who performs well under pressure. <\/li><li>Organized and detail-oriented professional. <\/li><li>Practical problem solver with a hands-on approach. <\/li><li>Ability to balance technical and operational priorities. <\/li><li>Collaborative team player who can effectively work with field crews, contractors, technical specialists, and leadership teams. <\/li><\/ul><p><strong>Employment Details<\/strong><\/p><ul><li>6-month contract assignment. <\/li><li>Potential for extension based on project needs and performance. <\/li><li>Full-time schedule. <\/li><li>Regular travel to project sites required. <\/li><\/ul><p><strong>Equal Opportunity Employer<\/strong><\/p><p>Turner Staffing Group is an Equal Opportunity Employer. All qualified applicants will receive consideration for employment without regard to race, color, religion, sex, national origin, age, disability, veteran status, or any other protected status under applicable law.<\/p><p><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p>","post_title":"Project Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/project-geologist\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Kirkland","%location_state_id%":"AZ","%location_city_state%":"Kirkland, AZ","%description%":"<p>Turner Staffing Group is seeking an experienced <strong>Exploration Project Geologist<\/strong> for a 6-month project assignment with the possibility of extension. This role supports exploration drilling programs and field operations, combining technical geology expertise with project coordination, contractor management, and exploration program oversight.<\/p><p>The ideal candidate will have hands-on core logging experience and a proven track record supporting or managing exploration drilling programs in active field environments. This position requires regular travel to project sites throughout Arizona and close collaboration with geologists, drilling contractors, and project stakeholders.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Coordinate exploration drilling activities and day-to-day field operations. <\/li><li>Ensure equipment, field supplies, and materials arrive on schedule. <\/li><li>Manage field schedules and drill program work plans. <\/li><li>Monitor project progress including drilling, logging, sampling, scanning, and assay workflows. <\/li><li>Oversee contractor and vendor performance. <\/li><li>Support compliance with health, safety, environmental, and regulatory requirements. <\/li><li>Troubleshoot operational challenges that impact schedules, budgets, or project objectives. <\/li><li>Identify project risks and develop mitigation strategies. <\/li><li>Provide regular project updates and status reports to stakeholders. <\/li><li>Support the review and interpretation of exploration data and results. <\/li><li>Collaborate with technical teams to evaluate findings and recommend next phases of work. <\/li><li>Balance operational priorities with technical exploration objectives. <\/li><\/ul><p><strong>Typical Responsibilities<\/strong><\/p><p>A typical day may include:<\/p><ul><li>Reviewing drilling progress and inspecting core retrieval activities. <\/li><li>Coordinating with drilling contractors and resolving field issues. <\/li><li>Updating project schedules, trackers, and reporting tools. <\/li><li>Meeting with geologists and project stakeholders to review exploration results. <\/li><li>Reporting project risks, milestones, and recommendations. <\/li><li>Supporting ongoing program adjustments based on new geological information. <\/li><\/ul><p><strong>Required Qualifications<\/strong><\/p><ul><li>Bachelor's degree in Geology, Geoscience, Geological Engineering, or a related field. <\/li><li>3-7 years of mineral exploration experience. <\/li><li>Hands-on experience logging drill core and supporting exploration drilling programs. <\/li><li>Experience coordinating field operations, contractors, and exploration activities. <\/li><li>Strong understanding of drilling, sampling, and exploration workflows. <\/li><li>Ability to work independently in remote field environments. <\/li><li>Excellent organizational, communication, and problem-solving skills. <\/li><li>Proficiency with Microsoft Office and standard geological data management systems. <\/li><li>Ability to travel regularly to project sites throughout Arizona. <\/li><\/ul><p><strong>Preferred Qualifications<\/strong><\/p><ul><li>Experience managing exploration drill programs. <\/li><li>Experience working with multiple contractors and vendors. <\/li><li>Knowledge of exploration project budgeting and scheduling. <\/li><li>Familiarity with safety and environmental compliance requirements within mining operations. <\/li><\/ul><p><strong>What We're Looking For<\/strong><\/p><ul><li>Strong communicator who performs well under pressure. <\/li><li>Organized and detail-oriented professional. <\/li><li>Practical problem solver with a hands-on approach. <\/li><li>Ability to balance technical and operational priorities. <\/li><li>Collaborative team player who can effectively work with field crews, contractors, technical specialists, and leadership teams. <\/li><\/ul><p><strong>Employment Details<\/strong><\/p><ul><li>6-month contract assignment. <\/li><li>Potential for extension based on project needs and performance. <\/li><li>Full-time schedule. <\/li><li>Regular travel to project sites required. <\/li><\/ul><p><strong>Equal Opportunity Employer<\/strong><\/p><p>Turner Staffing Group is an Equal Opportunity Employer. All qualified applicants will receive consideration for employment without regard to race, color, religion, sex, national origin, age, disability, veteran status, or any other protected status under applicable law.<\/p><p><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/cq8p3i8x56dedr9yuxisx1nize","%crelate_id%":"cq8p3i8x56dedr9yuxisx1nize","%crelate_created_date%":"2026-06-02T07:49:08.85Z","%crelate_updated_date%":"2026-06-04T14:05:41.05Z","%_wpgmp_location_city%":"Kirkland","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kirkland, AZUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.4316071","%_wpgmp_metabox_longitude%":"-112.7435171","%rank_math_internal_links_processed%":"1"}},"id":3738,"infowindow_disable":false},{"source":"post","title":"Sr. Project Manager\/Estimator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Sr. Project Manager\/Estimator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview The Project Manager\/Estimator will serve as a right-hand leader to ownership. This is a hands-on, high-impact role for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/sr-project-manager-estimator\/\" name=\"Sr. Project Manager\/Estimator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview The Project Manager\/Estimator will serve as a right-hand leader to ownership. This is a hands-on, high-impact role for&hellip;","address":"Seattle, WA, USA","location":{"lat":"47.6061389","city":"Seattle","state":"WA","country":"United States","lng":"-122.3328481","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/sr-project-manager-estimator\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview The Project Manager\/Estimator will serve as a right-hand leader to ownership. This is a hands-on, high-impact role for&hellip;","post_content":"<p><strong>Position Overview<\/strong><\/p>\n<p>The  Project Manager\/Estimator will serve as a right-hand leader to ownership. This is a hands-on, high-impact role for someone who understands public works, underground utilities, change order management, estimating, and the day-to-day pace of a lean contractor environment. The ideal candidate is not looking for a narrow corporate role; they are comfortable wearing multiple hats, working closely with ownership, and helping build the next stage of the company.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Key Responsibilities<\/strong><\/p>\n<p>\u2022\tManage approximately 3-5 active heavy civil\/public works projects at a time, generally ranging from $500K to $10M.<\/p>\n<p>\u2022\tLead project management functions including change order management, project documentation, owner\/client communication, schedule coordination, and issue resolution.<\/p>\n<p>\u2022\tSupport estimating and bidding efforts, with an emphasis on public works and underground utility scopes.<\/p>\n<p>\u2022\tCoordinate with the owner, construction manager, field foremen, crews, subcontractors, suppliers, and public-sector stakeholders.<\/p>\n<p>\u2022\tManage subcontractors and ensure work is coordinated, documented, and executed properly.<\/p>\n<p>\u2022\tHelp evaluate resource allocation, job sequencing, manpower needs, equipment needs, backlog, and upcoming bid opportunities.<\/p>\n<p>\u2022\tDevelop and maintain relationships with private developers, homebuilders, and local market contacts where appropriate.<\/p>\n<p>\u2022\tHelp bring additional structure, process, and operational discipline to a lean, growing contractor.<\/p>\n<p>\u2022\tRemain hands-on and available to visit jobsites, understand field conditions, and support field execution when needed.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Relevant Project Experience<\/strong><\/p>\n<p>\u2022\tPublic works \/ municipal infrastructure projects.<\/p>\n<p>\u2022\tUnderground utilities, especially sewer, water, and storm systems.<\/p>\n<p>\u2022\tRoadway and civil infrastructure associated with underground utility work.<\/p>\n<p>\u2022\tSite development, plat work, and land development experience is a plus.<\/p>\n<p>\u2022\tExperience with public bid environments, and change order documentation.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Ideal Candidate Profile<\/strong><\/p>\n<p>\u2022\t7 - 10+ years of relevant heavy civil construction experience preferred.<\/p>\n<p>\u2022\tStrong public works and underground utility experience.<\/p>\n<p>\u2022\tComfortable operating in a lean, non-union environment where people wear multiple hats.<\/p>\n<p>\u2022\tHigh value placed on work ethic, ownership mentality, and willingness to do what is needed to help the company grow.<\/p>\n<p>\u2022\tLocal market knowledge and relationships with developers, municipalities, homebuilders, engineers, or public agencies are valuable.<\/p>\n<p>\u2022\tStrong fit with a family-owned, relationship-driven, hands-on culture.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Tools \/ Systems<\/strong><\/p>\n<p>Experience with MS Excel and HeavyBid preferred<\/p>","post_title":"Sr. Project Manager\/Estimator","post_link":"https:\/\/turnerstaffing.com\/position\/sr-project-manager-estimator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Seattle","%location_state_id%":"WA","%location_state_name%":"Washington","%location_city_state%":"Seattle, WA","%education%":"","%department%":"TSG","%description%":"<p><strong>Position Overview<\/strong><\/p>\n<p>The  Project Manager\/Estimator will serve as a right-hand leader to ownership. This is a hands-on, high-impact role for someone who understands public works, underground utilities, change order management, estimating, and the day-to-day pace of a lean contractor environment. The ideal candidate is not looking for a narrow corporate role; they are comfortable wearing multiple hats, working closely with ownership, and helping build the next stage of the company.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Key Responsibilities<\/strong><\/p>\n<p>\u2022\tManage approximately 3-5 active heavy civil\/public works projects at a time, generally ranging from $500K to $10M.<\/p>\n<p>\u2022\tLead project management functions including change order management, project documentation, owner\/client communication, schedule coordination, and issue resolution.<\/p>\n<p>\u2022\tSupport estimating and bidding efforts, with an emphasis on public works and underground utility scopes.<\/p>\n<p>\u2022\tCoordinate with the owner, construction manager, field foremen, crews, subcontractors, suppliers, and public-sector stakeholders.<\/p>\n<p>\u2022\tManage subcontractors and ensure work is coordinated, documented, and executed properly.<\/p>\n<p>\u2022\tHelp evaluate resource allocation, job sequencing, manpower needs, equipment needs, backlog, and upcoming bid opportunities.<\/p>\n<p>\u2022\tDevelop and maintain relationships with private developers, homebuilders, and local market contacts where appropriate.<\/p>\n<p>\u2022\tHelp bring additional structure, process, and operational discipline to a lean, growing contractor.<\/p>\n<p>\u2022\tRemain hands-on and available to visit jobsites, understand field conditions, and support field execution when needed.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Relevant Project Experience<\/strong><\/p>\n<p>\u2022\tPublic works \/ municipal infrastructure projects.<\/p>\n<p>\u2022\tUnderground utilities, especially sewer, water, and storm systems.<\/p>\n<p>\u2022\tRoadway and civil infrastructure associated with underground utility work.<\/p>\n<p>\u2022\tSite development, plat work, and land development experience is a plus.<\/p>\n<p>\u2022\tExperience with public bid environments, and change order documentation.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Ideal Candidate Profile<\/strong><\/p>\n<p>\u2022\t7 - 10+ years of relevant heavy civil construction experience preferred.<\/p>\n<p>\u2022\tStrong public works and underground utility experience.<\/p>\n<p>\u2022\tComfortable operating in a lean, non-union environment where people wear multiple hats.<\/p>\n<p>\u2022\tHigh value placed on work ethic, ownership mentality, and willingness to do what is needed to help the company grow.<\/p>\n<p>\u2022\tLocal market knowledge and relationships with developers, municipalities, homebuilders, engineers, or public agencies are valuable.<\/p>\n<p>\u2022\tStrong fit with a family-owned, relationship-driven, hands-on culture.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Tools \/ Systems<\/strong><\/p>\n<p>Experience with MS Excel and HeavyBid preferred<\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/09128e00991f-sr-project-manager-estimator","%breezy_id%":"09128e00991f","%breezy_friendly_id%":"09128e00991f-sr-project-manager-estimator","%breezy_created_date%":"2026-06-01T21:16:49.815Z","%breezy_updated_date%":"2026-06-01T21:17:48.935Z","%_wpgmp_location_city%":"Seattle","%_wpgmp_location_state%":"WA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Seattle, WA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"47.6061389","%_wpgmp_metabox_longitude%":"-122.3328481","%rank_math_internal_links_processed%":"1"}},"id":3730,"infowindow_disable":false},{"source":"post","title":"Asphalt Plant Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Asphalt Plant Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Summary We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/asphalt-plant-superintendent\/\" name=\"Asphalt Plant Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Summary We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients&hellip;","address":"Bend, OR, USA","location":{"lat":"44.0581728","city":"Bend","state":"OR","country":"United States","lng":"-121.3153096","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/asphalt-plant-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Position Summary We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients&hellip;","post_content":"<p>Position Summary<\/p>\n<p>We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients in Central and Eastern Oregon. This position is responsible for overseeing daily asphalt plant operations, production schedules, plant maintenance, repairs, and safety compliance. The ideal candidate will possess strong leadership skills, extensive knowledge of asphalt plant operations, and the ability to manage personnel, equipment, and plant performance efficiently and safely.<\/p>\n<p>Essential Duties and Responsibilities<\/p>\n<p>\u2022\tTroubleshoot plant operational issues, electrical systems, PLC controls, burners, and material flow systems<\/p>\n<p>\u2022\tSupervise and coordinate asphalt plant operations and personnel<\/p>\n<p>\u2022\tManage daily production schedules to meet project and customer demands<\/p>\n<p>\u2022\tMonitor asphalt mix production for compliance with job specifications and quality standards<\/p>\n<p>\u2022\tCoordinate plant maintenance, repairs, and preventative maintenance programs<\/p>\n<p>\u2022\tEnsure compliance with OSHA, MSHA, DEQ, environmental, and company safety regulations<\/p>\n<p>\u2022\tCoordinate aggregate, oil, and liquid AC inventory levels and deliveries with plant operators<\/p>\n<p>\u2022\tCommunicate and work effectively with paving crews, truck dispatch, quality control staff, and management teams<\/p>\n<p>\u2022\tMaintain accurate production reports, inventory records, maintenance documentation, and parts inventory<\/p>\n<p>\u2022\tTrain, mentor, and evaluate plant personnel<\/p>\n<p>\u2022\tEnsure proper housekeeping and organization of the plant site<\/p>\n<p>Qualifications<\/p>\n<p>\u2022\tMinimum 5 years of asphalt plant operations experience preferred<\/p>\n<p>\u2022\tMechanical and troubleshooting experience with asphalt plant equipment required<\/p>\n<p>\u2022\tPrevious supervisory or management experience preferred<\/p>\n<p>\u2022\tExperience with plant automation systems and PLC controls preferred<\/p>\n<p>\u2022\tUnderstanding of OSHA, MSHA, and environmental compliance requirements<\/p>\n<p>\u2022\tAbility to work flexible hours, including nights and weekends during paving season<\/p>\n<p>\u2022\tStrong leadership, organizational, and communication skills<\/p>\n<p>Benefits<\/p>\n<p>\u2022\tParticipation in company profit sharing program<\/p>\n<p>\u2022\tCompany-paid health and dental insurance (employee contribution may apply)<\/p>\n<p>\u2022\tPaid time off:<\/p>\n<p>o\tYears 1\u20133: 2 weeks<\/p>\n<p>o\tYears 4\u20135: 3 weeks<\/p>\n<p>o\tYears 6+: 4 weeks<\/p>\n<p>\u2022\t401(k) with employee deferral, matching, and profit sharing opportunities<\/p>\n<p>\u2022\tPaid holidays:<\/p>\n<p>o\tTwo paid holidays after the first year of employment, increasing by two per year up to a maximum of six paid holidays<\/p>\n<p>\u2022\tCompany vehicle<\/p>\n<p>\u2022\tCompany cell phone<\/p>\n<p>\u2022\tCompany laptop<\/p>","post_title":"Asphalt Plant Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/asphalt-plant-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Bend","%location_state_id%":"OR","%location_state_name%":"Oregon","%location_city_state%":"Bend, OR","%education%":"Unspecified","%department%":"TSG","%description%":"<p>Position Summary<\/p>\n<p>We are seeking an experienced and motivated Asphalt Plant Superintendent to support one of our construction industry clients in Central and Eastern Oregon. This position is responsible for overseeing daily asphalt plant operations, production schedules, plant maintenance, repairs, and safety compliance. The ideal candidate will possess strong leadership skills, extensive knowledge of asphalt plant operations, and the ability to manage personnel, equipment, and plant performance efficiently and safely.<\/p>\n<p>Essential Duties and Responsibilities<\/p>\n<p>\u2022\tTroubleshoot plant operational issues, electrical systems, PLC controls, burners, and material flow systems<\/p>\n<p>\u2022\tSupervise and coordinate asphalt plant operations and personnel<\/p>\n<p>\u2022\tManage daily production schedules to meet project and customer demands<\/p>\n<p>\u2022\tMonitor asphalt mix production for compliance with job specifications and quality standards<\/p>\n<p>\u2022\tCoordinate plant maintenance, repairs, and preventative maintenance programs<\/p>\n<p>\u2022\tEnsure compliance with OSHA, MSHA, DEQ, environmental, and company safety regulations<\/p>\n<p>\u2022\tCoordinate aggregate, oil, and liquid AC inventory levels and deliveries with plant operators<\/p>\n<p>\u2022\tCommunicate and work effectively with paving crews, truck dispatch, quality control staff, and management teams<\/p>\n<p>\u2022\tMaintain accurate production reports, inventory records, maintenance documentation, and parts inventory<\/p>\n<p>\u2022\tTrain, mentor, and evaluate plant personnel<\/p>\n<p>\u2022\tEnsure proper housekeeping and organization of the plant site<\/p>\n<p>Qualifications<\/p>\n<p>\u2022\tMinimum 5 years of asphalt plant operations experience preferred<\/p>\n<p>\u2022\tMechanical and troubleshooting experience with asphalt plant equipment required<\/p>\n<p>\u2022\tPrevious supervisory or management experience preferred<\/p>\n<p>\u2022\tExperience with plant automation systems and PLC controls preferred<\/p>\n<p>\u2022\tUnderstanding of OSHA, MSHA, and environmental compliance requirements<\/p>\n<p>\u2022\tAbility to work flexible hours, including nights and weekends during paving season<\/p>\n<p>\u2022\tStrong leadership, organizational, and communication skills<\/p>\n<p>Benefits<\/p>\n<p>\u2022\tParticipation in company profit sharing program<\/p>\n<p>\u2022\tCompany-paid health and dental insurance (employee contribution may apply)<\/p>\n<p>\u2022\tPaid time off:<\/p>\n<p>o\tYears 1\u20133: 2 weeks<\/p>\n<p>o\tYears 4\u20135: 3 weeks<\/p>\n<p>o\tYears 6+: 4 weeks<\/p>\n<p>\u2022\t401(k) with employee deferral, matching, and profit sharing opportunities<\/p>\n<p>\u2022\tPaid holidays:<\/p>\n<p>o\tTwo paid holidays after the first year of employment, increasing by two per year up to a maximum of six paid holidays<\/p>\n<p>\u2022\tCompany vehicle<\/p>\n<p>\u2022\tCompany cell phone<\/p>\n<p>\u2022\tCompany laptop<\/p>","%category%":"Management","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a2c04e5af23c-asphalt-plant-superintendent","%breezy_id%":"a2c04e5af23c","%breezy_friendly_id%":"a2c04e5af23c-asphalt-plant-superintendent","%breezy_created_date%":"2026-05-27T17:36:22.804Z","%breezy_updated_date%":"2026-05-27T17:36:53.819Z","%_wpgmp_location_city%":"Bend","%_wpgmp_location_state%":"OR","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bend, OR, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"44.0581728","%_wpgmp_metabox_longitude%":"-121.3153096","%rank_math_internal_links_processed%":"1"}},"id":3727,"infowindow_disable":false},{"source":"post","title":"Material Handler","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Material Handler\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY: Load material into railcars or trucks in a safe and efficient manner; and perform all other assigned tasks&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/material-handler\/\" name=\"Material Handler\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY: Load material into railcars or trucks in a safe and efficient manner; and perform all other assigned tasks&hellip;","address":"Ocala, FL, USA","location":{"lat":"29.1850783","city":"Ocala","state":"FL","country":"United States","lng":"-82.1342596","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/material-handler\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: Load material into railcars or trucks in a safe and efficient manner; and perform all other assigned tasks&hellip;","post_content":"<p><strong>POSITION SUMMARY<\/strong>: Load material into railcars or trucks in a safe and efficient manner; and perform all other assigned tasks not specifically indicated.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS: <\/strong><\/p>\n<p>1. Report any potential operational or safety problems to supervision.<\/p>\n<p>2. Perform all work assigned in a neat and orderly manner, strictly adhering to Company and<\/p>\n<p>governmental and safety rules and regulations.<\/p>\n<p>3. Ensure proper material and weight is loaded for each shipment.<\/p>\n<p>4. Maintain accurate records for each load of product shipped.<\/p>\n<p>5. Obtain samples for quality control as required.<\/p>\n<p>6. Maintain a clean and safe work area.<\/p>\n<p>7. Must be able to perform minor maintenance tasks on load-out mobile and mechanical<\/p>\n<p>equipment<\/p>\n<p>8. Assist fire deck crew as necessary.<\/p>\n<p>9. Keep rail and truck scales clean.<\/p>\n<p><\/p>\n<p><\/p>\n<p>ATTRIBUTES:<\/p>\n<p>\u00b7 Must be physically capable of accessing all plant locations.<\/p>\n<p>\u00b7 Must be capable of performing the essential job duties required of this position.<\/p>\n<p>\u00b7 Must be able to effectively communicate and interact with supervisors and peers. \u00b7 Must be capable of working shift work, seven days a week.<\/p>\n<p>\u00b7 Must be able to read, write, and perform basic mathematical computations.<\/p>\n<p>\u00b7 Must demonstrate the ability to maintain a smooth and efficient flow of truck and rail traffic.<\/p>\n<p>\u00b7 Must have a working telephone number and be receptive to call-outs.<\/p>\n<p>\u00b7 Must be able to operate track-mobile, various front end loaders and other equipment necessary to perform job functions in a safe and efficient manner.<\/p>\n<p>\u00b7 Must be able to open truck and railcar lids.<\/p>\n<p>\u00b7 Must be able to work outside in severe weather conditions.<\/p>\n<p><\/p>\n<p>Required Education: High school diploma or GED equivalent, or demonstrated skills or ability.<\/p>","post_title":"Material Handler","post_link":"https:\/\/turnerstaffing.com\/position\/material-handler\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Ocala","%location_state_id%":"FL","%location_state_name%":"Florida","%location_city_state%":"Ocala, FL","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong>POSITION SUMMARY<\/strong>: Load material into railcars or trucks in a safe and efficient manner; and perform all other assigned tasks not specifically indicated.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS: <\/strong><\/p>\n<p>1. Report any potential operational or safety problems to supervision.<\/p>\n<p>2. Perform all work assigned in a neat and orderly manner, strictly adhering to Company and<\/p>\n<p>governmental and safety rules and regulations.<\/p>\n<p>3. Ensure proper material and weight is loaded for each shipment.<\/p>\n<p>4. Maintain accurate records for each load of product shipped.<\/p>\n<p>5. Obtain samples for quality control as required.<\/p>\n<p>6. Maintain a clean and safe work area.<\/p>\n<p>7. Must be able to perform minor maintenance tasks on load-out mobile and mechanical<\/p>\n<p>equipment<\/p>\n<p>8. Assist fire deck crew as necessary.<\/p>\n<p>9. Keep rail and truck scales clean.<\/p>\n<p><\/p>\n<p><\/p>\n<p>ATTRIBUTES:<\/p>\n<p>\u00b7 Must be physically capable of accessing all plant locations.<\/p>\n<p>\u00b7 Must be capable of performing the essential job duties required of this position.<\/p>\n<p>\u00b7 Must be able to effectively communicate and interact with supervisors and peers. \u00b7 Must be capable of working shift work, seven days a week.<\/p>\n<p>\u00b7 Must be able to read, write, and perform basic mathematical computations.<\/p>\n<p>\u00b7 Must demonstrate the ability to maintain a smooth and efficient flow of truck and rail traffic.<\/p>\n<p>\u00b7 Must have a working telephone number and be receptive to call-outs.<\/p>\n<p>\u00b7 Must be able to operate track-mobile, various front end loaders and other equipment necessary to perform job functions in a safe and efficient manner.<\/p>\n<p>\u00b7 Must be able to open truck and railcar lids.<\/p>\n<p>\u00b7 Must be able to work outside in severe weather conditions.<\/p>\n<p><\/p>\n<p>Required Education: High school diploma or GED equivalent, or demonstrated skills or ability.<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/89871dbbe9bd-material-handler","%breezy_id%":"89871dbbe9bd","%breezy_friendly_id%":"89871dbbe9bd-material-handler","%breezy_created_date%":"2026-05-05T21:49:00.316Z","%breezy_updated_date%":"2026-06-09T21:47:07.257Z","%_wpgmp_location_city%":"Ocala","%_wpgmp_location_state%":"FL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ocala, FL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.1850783","%_wpgmp_metabox_longitude%":"-82.1342596","%rank_math_internal_links_processed%":"1"}},"id":3718,"infowindow_disable":false},{"source":"post","title":"Pipe Layer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Pipe Layer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Pipe Layer Location: Bowmansville, PA Schedule: Monday \u2013 Friday Occasional Saturdays as needed Day Shift Job Summary: We&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-layer\/\" name=\"Pipe Layer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Pipe Layer Location: Bowmansville, PA Schedule: Monday \u2013 Friday Occasional Saturdays as needed Day Shift Job Summary: We&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pipe-layer\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Pipe Layer Location: Bowmansville, PA Schedule: Monday \u2013 Friday Occasional Saturdays as needed Day Shift Job Summary: We&hellip;","post_content":"<h2><strong>Job Title: Pipe Layer<\/strong><\/h2>\n<h3><strong>Location:<\/strong><\/h3>\n<p>Bowmansville, PA<\/p>\n<h3><strong>Schedule:<\/strong><\/h3>\n<ul>\n<li>\nMonday \u2013 Friday\n<\/li>\n<li>\nOccasional Saturdays as needed\n<\/li>\n<li>Day Shift<\/li>\n<\/ul>\n<h2><strong>Job Summary:<\/strong><\/h2>\n<p>We are seeking an experienced Pipe Layer to join our construction team working on underground utility projects. This role involves installing, assembling, and maintaining various types of piping systems including sanitary, storm, and sewer lines. The ideal candidate will have hands-on experience in trench work and utility installation and be comfortable working in a fast-paced, outdoor environment.<\/p>\n<h2><strong>Key Responsibilities:<\/strong><\/h2>\n<ul>\n<li>\nInstall sanitary sewer, storm drain, and water\/sewer piping systems\n<\/li>\n<li>\nPerform trench layout, grading, and pipe alignment according to project specifications\n<\/li>\n<li>\nRead and interpret blueprints, grade stakes, and site plans\n<\/li>\n<li>\nEnsure proper pipe slope, alignment, and depth\n<\/li>\n<li>\nAssist with trench preparation, including shoring and safety compliance\n<\/li>\n<li>\nWork alongside equipment operators and laborers to complete installations efficiently\n<\/li>\n<li>\nPerform backfilling and compaction as required\n<\/li>\n<li>\nMaintain a safe and clean work environment in compliance with OSHA standards\n<\/li>\n<\/ul>\n<h2><strong>Qualifications:<\/strong><\/h2>\n<ul>\n<li>\nMinimum <strong>2+ years of proven pipe laying experience<\/strong> in construction or utility work\n<\/li>\n<li>\nExperience with <strong>sanitary, storm, and sewer piping systems<\/strong> required\n<\/li>\n<li>\nAbility to read and interpret construction plans and grade stakes\n<\/li>\n<li>\nKnowledge of trenching and excavation safety practices\n<\/li>\n<li>\nAbility to work outdoors in varying weather conditions\n<\/li>\n<li>\nStrong work ethic and ability to work as part of a team\n<\/li>\n<\/ul>\n<h2><strong>Preferred Qualifications:<\/strong><\/h2>\n<ul>\n<li>\nExperience working in heavy civil or underground utility construction\n<\/li>\n<li>\nFamiliarity with equipment such as excavators and backhoes\n<\/li>\n<li>\nOSHA 10 or OSHA 30 certification is a plus\n<\/li>\n<\/ul>\n<h2><strong>Physical Requirements:<\/strong><\/h2>\n<ul>\n<li>\nAbility to lift 50+ lbs regularly\n<\/li>\n<li>\nAbility to stand, bend, kneel, and work in trenches for extended periods\n<\/li>\n<li>\nComfortable working long hours as needed<\/li><\/ul>","post_title":"Pipe Layer","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-layer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"Unspecified","%department%":"TSG","%description%":"<h2><strong>Job Title: Pipe Layer<\/strong><\/h2>\n<h3><strong>Location:<\/strong><\/h3>\n<p>Bowmansville, PA<\/p>\n<h3><strong>Schedule:<\/strong><\/h3>\n<ul>\n<li>\nMonday \u2013 Friday\n<\/li>\n<li>\nOccasional Saturdays as needed\n<\/li>\n<li>Day Shift<\/li>\n<\/ul>\n<h2><strong>Job Summary:<\/strong><\/h2>\n<p>We are seeking an experienced Pipe Layer to join our construction team working on underground utility projects. This role involves installing, assembling, and maintaining various types of piping systems including sanitary, storm, and sewer lines. The ideal candidate will have hands-on experience in trench work and utility installation and be comfortable working in a fast-paced, outdoor environment.<\/p>\n<h2><strong>Key Responsibilities:<\/strong><\/h2>\n<ul>\n<li>\nInstall sanitary sewer, storm drain, and water\/sewer piping systems\n<\/li>\n<li>\nPerform trench layout, grading, and pipe alignment according to project specifications\n<\/li>\n<li>\nRead and interpret blueprints, grade stakes, and site plans\n<\/li>\n<li>\nEnsure proper pipe slope, alignment, and depth\n<\/li>\n<li>\nAssist with trench preparation, including shoring and safety compliance\n<\/li>\n<li>\nWork alongside equipment operators and laborers to complete installations efficiently\n<\/li>\n<li>\nPerform backfilling and compaction as required\n<\/li>\n<li>\nMaintain a safe and clean work environment in compliance with OSHA standards\n<\/li>\n<\/ul>\n<h2><strong>Qualifications:<\/strong><\/h2>\n<ul>\n<li>\nMinimum <strong>2+ years of proven pipe laying experience<\/strong> in construction or utility work\n<\/li>\n<li>\nExperience with <strong>sanitary, storm, and sewer piping systems<\/strong> required\n<\/li>\n<li>\nAbility to read and interpret construction plans and grade stakes\n<\/li>\n<li>\nKnowledge of trenching and excavation safety practices\n<\/li>\n<li>\nAbility to work outdoors in varying weather conditions\n<\/li>\n<li>\nStrong work ethic and ability to work as part of a team\n<\/li>\n<\/ul>\n<h2><strong>Preferred Qualifications:<\/strong><\/h2>\n<ul>\n<li>\nExperience working in heavy civil or underground utility construction\n<\/li>\n<li>\nFamiliarity with equipment such as excavators and backhoes\n<\/li>\n<li>\nOSHA 10 or OSHA 30 certification is a plus\n<\/li>\n<\/ul>\n<h2><strong>Physical Requirements:<\/strong><\/h2>\n<ul>\n<li>\nAbility to lift 50+ lbs regularly\n<\/li>\n<li>\nAbility to stand, bend, kneel, and work in trenches for extended periods\n<\/li>\n<li>\nComfortable working long hours as needed<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3677f263ab2f-pipe-layer","%breezy_id%":"3677f263ab2f","%breezy_friendly_id%":"3677f263ab2f-pipe-layer","%breezy_created_date%":"2026-04-14T15:27:19.191Z","%breezy_updated_date%":"2026-05-22T20:50:06.994Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":3716,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    General Purpose: The Heavy Equipment Mechanic will be responsible for ensuring the functionality, safety, and longevity of heavy-duty machinery and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-3\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"General Purpose: The Heavy Equipment Mechanic will be responsible for ensuring the functionality, safety, and longevity of heavy-duty machinery and&hellip;","address":"Colton, CA, USA","location":{"lat":"34.0739016","city":"Colton","state":"CA","country":"United States","lng":"-117.3136547","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-3\/","zoom":19,"extra_fields":{"post_excerpt":"General Purpose: The Heavy Equipment Mechanic will be responsible for ensuring the functionality, safety, and longevity of heavy-duty machinery and&hellip;","post_content":"<p><strong>General Purpose: <\/strong><\/p>\n<p>The Heavy Equipment Mechanic will be responsible for ensuring the functionality, safety, and longevity of heavy-duty machinery and equipment. This role involves conducting inspections, repairs, and routine maintenance while adhering to safety standards and promoting operational efficiency. <\/p>\n<p><strong>Essential Duties: <\/strong><\/p>\n<p>\u2022 Inspect equipment engines and mechanical\/electrical components to diagnose issues accurately, utilizing diagnostic tools and computerized testing equipment. <\/p>\n<p>\u2022 Conduct routine maintenance tasks, including replacing fluids, lubricating parts, and adjusting components, to ensure optimal functionality and longevity of equipment. <\/p>\n<p>\u2022 Schedule and plan maintenance sessions in coordination with the Department Managers to minimize downtime. <\/p>\n<p>\u2022 Repair or replace broken or worn components, such as hydraulic systems, hydraulic cylinders, hoses, and 12V or 24V electrical systems. <\/p>\n<p>\u2022 Perform welding and metal fabrication to repair or reinforce machinery and structural components. <\/p>\n<p>\u2022 Inspect and test heavy-duty equipment such as excavators, grapples, shears, bobcats, forklifts, and other machinery to identify faults or safety concerns. <\/p>\n<p>\u2022 Clean, lubricate, and service machine attachments like winches, blades, and side booms to maintain operational efficiency. <\/p>\n<p>\u2022 Perform major repair work when necessary, consulting with other mechanics or specialists for larger or complex repairs. <\/p>\n<p>\u2022 Develop and implement preventative maintenance plans to reduce equipment failures and extend the lifespan of machinery. <\/p>\n<p>\u2022 Maintain detailed records of maintenance and repair activities, including parts used, time spent, and diagnostics performed, utilizing the company\u2019s computerized maintenance management system (CMMS). <\/p>\n<p>\u2022 Monitor inventory levels, identify low-stock items, and coordinate with management to reorder parts, tools, and supplies. <\/p>\n<p>\u2022 Adhere to all safety protocols, regulations, and standards to ensure a safe work environment. Participate in regular safety training and meetings. <\/p>\n<p>\u2022 Collaborate with team members and provide guidance to equipment operators on preventative maintenance practices and safe usage procedures. <\/p>\n<p>\u2022 Conduct routine inspections and cleaning of tools, work areas, and equipment to ensure a safe and organized workspace. <\/p>\n<p>\u2022 Report damaged or faulty equipment to management immediately and suggest solutions to prevent reoccurrence. <\/p>\n<p><strong><br><\/strong><\/p>\n<p><strong>Education\/Experience:  <\/strong><\/p>\n<p>\u2022 Minimum of 8-10 years of experience in the maintenance and repair of heavy machinery is preferred. <\/p>\n<p>\u2022 Proficiency in troubleshooting hydraulic systems, repairing hydraulic cylinders, and diagnosing 12V and 24V electrical systems is essential. <\/p>\n<p>\u2022 Experience with welding, metal fabrication, and advanced diagnostic tools is required. <\/p>\n<p>\u2022 Familiarity with reading and interpreting blueprints, technical manuals, and schematics is expected. <\/p>\n<p>\u2022 Familiarity with Computerized Maintenance Management Systems (CMMS) is a plus. Language Skills: Will be required to read and comprehend instructions, correspondence, and memos, to write correspondence, memos, and schedule; to effectively present information in one-on-one and small group situations to guests, clients, and fellow staff. <\/p>\n<p><\/p>\n<p>Mathematical Skills: Basic math skills required. <\/p>\n<p>Reasoning Ability: Problem solving, reasoning, and \u201cthinking out of the box\u201d will be a constant <\/p>\n<p>requirement; in addition, applying common sense understanding to better serve our guests\u2019 needs. <\/p>\n<p><strong><br><\/strong><\/p>\n<p><strong>Physical Demands:  <\/strong><\/p>\n<p>\u2022 Physically able to conduct inspections and carry equipment used for inspections. <\/p>\n<p>\u2022 Prolonged periods of walking and standing.  <\/p>\n<p>\u2022 Must be able to lift up, push and pull to 40 pounds at a time. <\/p>\n<p>\u2022 Consistently climbs, balances, stoops, kneels, crawls or crouches.   <\/p>\n<p>\u2022 Consistently turning and moving of hands, arms, feet, and legs. <\/p>\n<p><strong><br><\/strong><\/p>\n<p><strong>Vision Requirements: <\/strong><\/p>\n<p>Regularly uses close, distance, color, and peripheral vision as well as depth perception. Ability to adjust focus. <\/p>\n<p><strong><u>Environment\/Noise:  <\/u><\/strong><\/p>\n<p>Work in a variety of environments, including outdoor conditions with exposure to extreme temperatures and occasional wet areas.<\/p>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Colton","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Colton, CA","%education%":"","%department%":"TSG","%description%":"<p><strong>General Purpose: <\/strong><\/p>\n<p>The Heavy Equipment Mechanic will be responsible for ensuring the functionality, safety, and longevity of heavy-duty machinery and equipment. This role involves conducting inspections, repairs, and routine maintenance while adhering to safety standards and promoting operational efficiency. <\/p>\n<p><strong>Essential Duties: <\/strong><\/p>\n<p>\u2022 Inspect equipment engines and mechanical\/electrical components to diagnose issues accurately, utilizing diagnostic tools and computerized testing equipment. <\/p>\n<p>\u2022 Conduct routine maintenance tasks, including replacing fluids, lubricating parts, and adjusting components, to ensure optimal functionality and longevity of equipment. <\/p>\n<p>\u2022 Schedule and plan maintenance sessions in coordination with the Department Managers to minimize downtime. <\/p>\n<p>\u2022 Repair or replace broken or worn components, such as hydraulic systems, hydraulic cylinders, hoses, and 12V or 24V electrical systems. <\/p>\n<p>\u2022 Perform welding and metal fabrication to repair or reinforce machinery and structural components. <\/p>\n<p>\u2022 Inspect and test heavy-duty equipment such as excavators, grapples, shears, bobcats, forklifts, and other machinery to identify faults or safety concerns. <\/p>\n<p>\u2022 Clean, lubricate, and service machine attachments like winches, blades, and side booms to maintain operational efficiency. <\/p>\n<p>\u2022 Perform major repair work when necessary, consulting with other mechanics or specialists for larger or complex repairs. <\/p>\n<p>\u2022 Develop and implement preventative maintenance plans to reduce equipment failures and extend the lifespan of machinery. <\/p>\n<p>\u2022 Maintain detailed records of maintenance and repair activities, including parts used, time spent, and diagnostics performed, utilizing the company\u2019s computerized maintenance management system (CMMS). <\/p>\n<p>\u2022 Monitor inventory levels, identify low-stock items, and coordinate with management to reorder parts, tools, and supplies. <\/p>\n<p>\u2022 Adhere to all safety protocols, regulations, and standards to ensure a safe work environment. Participate in regular safety training and meetings. <\/p>\n<p>\u2022 Collaborate with team members and provide guidance to equipment operators on preventative maintenance practices and safe usage procedures. <\/p>\n<p>\u2022 Conduct routine inspections and cleaning of tools, work areas, and equipment to ensure a safe and organized workspace. <\/p>\n<p>\u2022 Report damaged or faulty equipment to management immediately and suggest solutions to prevent reoccurrence. <\/p>\n<p><strong><br><\/strong><\/p>\n<p><strong>Education\/Experience:  <\/strong><\/p>\n<p>\u2022 Minimum of 8-10 years of experience in the maintenance and repair of heavy machinery is preferred. <\/p>\n<p>\u2022 Proficiency in troubleshooting hydraulic systems, repairing hydraulic cylinders, and diagnosing 12V and 24V electrical systems is essential. <\/p>\n<p>\u2022 Experience with welding, metal fabrication, and advanced diagnostic tools is required. <\/p>\n<p>\u2022 Familiarity with reading and interpreting blueprints, technical manuals, and schematics is expected. <\/p>\n<p>\u2022 Familiarity with Computerized Maintenance Management Systems (CMMS) is a plus. Language Skills: Will be required to read and comprehend instructions, correspondence, and memos, to write correspondence, memos, and schedule; to effectively present information in one-on-one and small group situations to guests, clients, and fellow staff. <\/p>\n<p><\/p>\n<p>Mathematical Skills: Basic math skills required. <\/p>\n<p>Reasoning Ability: Problem solving, reasoning, and \u201cthinking out of the box\u201d will be a constant <\/p>\n<p>requirement; in addition, applying common sense understanding to better serve our guests\u2019 needs. <\/p>\n<p><strong><br><\/strong><\/p>\n<p><strong>Physical Demands:  <\/strong><\/p>\n<p>\u2022 Physically able to conduct inspections and carry equipment used for inspections. <\/p>\n<p>\u2022 Prolonged periods of walking and standing.  <\/p>\n<p>\u2022 Must be able to lift up, push and pull to 40 pounds at a time. <\/p>\n<p>\u2022 Consistently climbs, balances, stoops, kneels, crawls or crouches.   <\/p>\n<p>\u2022 Consistently turning and moving of hands, arms, feet, and legs. <\/p>\n<p><strong><br><\/strong><\/p>\n<p><strong>Vision Requirements: <\/strong><\/p>\n<p>Regularly uses close, distance, color, and peripheral vision as well as depth perception. Ability to adjust focus. <\/p>\n<p><strong><u>Environment\/Noise:  <\/u><\/strong><\/p>\n<p>Work in a variety of environments, including outdoor conditions with exposure to extreme temperatures and occasional wet areas.<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/6e23d441b96b-heavy-equipment-mechanic","%breezy_id%":"6e23d441b96b","%breezy_friendly_id%":"6e23d441b96b-heavy-equipment-mechanic","%breezy_created_date%":"2026-02-10T22:27:44.283Z","%breezy_updated_date%":"2026-05-22T20:48:31.049Z","%_wpgmp_location_city%":"Colton","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Colton, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0739016","%_wpgmp_metabox_longitude%":"-117.3136547","%rank_math_internal_links_processed%":"1"}},"id":3715,"infowindow_disable":false},{"source":"post","title":"CAT D6 Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    CAT D6 Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/cat-d6-dozer-operator\/\" name=\"CAT D6 Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in&hellip;","address":"Wells, NV, USA","location":{"lat":"41.1115888","city":"Wells","state":"NV","country":"United States","lng":"-114.96449","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/cat-d6-dozer-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in&hellip;","post_content":"<p>Job Summary:<\/p>\n\n<p>We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in Wells, Nevada. The ideal candidate will have at least 5 years of experience operating CAT D6 Dozers, with a strong focus on safety, efficiency, and quality. This position requires a dedicated professional to perform a variety of tasks related to construction, earthmoving, and site preparation on a project site.<\/p>\n<p><br><\/p>\n<p>Key Responsibilities:<\/p>\n<p>- Operate a CAT D6 Dozer for a variety of tasks including grading, leveling, clearing, and trenching on construction sites.<\/p>\n<p>- Perform pre-operation inspections and basic maintenance on the CAT D6 Dozer to ensure safe and efficient operation.<\/p>\n<p>- Follow project specifications and plans to ensure proper execution of work according to safety standards.<\/p>\n<p>- Work collaboratively with other equipment operators, laborers, and supervisors to meet project goals and deadlines.<\/p>\n<p>- Adhere to safety protocols and contribute to maintaining a safe work environment.<\/p>\n<p>- Communicate effectively with the team to coordinate tasks and report any issues or delays.<\/p>\n<p>- Complete necessary documentation and reports related to equipment use, work hours, and materials.<\/p>\n<p>---<\/p>\n<p>Required Qualifications:<\/p>\n<p>- Minimum 5 years of experience operating a CAT D6 Dozer or similar equipment in construction or heavy equipment operations.<\/p>\n<p>- Proven ability to perform tasks such as grading, clearing, and leveling with a high degree of precision.<\/p>\n<p>- Strong knowledge of equipment safety procedures and standard operating practices.<\/p>\n<p>- Ability to read and interpret project plans, blueprints, and specifications.<\/p>\n<p>- Valid driver\u2019s license and clean driving record.<\/p>\n<p>- Ability to perform basic machine maintenance, including lubricating and servicing equipment.<\/p>\n<p>- Must pass a pre-employment drug screening and background check.<\/p><p><br><\/p>\n\n<p>Preferred Qualifications:<\/p>\n<p>- Experience working in remote locations or with short-term contract positions.<\/p>\n<p>- Knowledge of additional heavy equipment operations.<\/p><p><br><\/p>\n\n<p>Physical Requirements:<\/p>\n<p>- Ability to lift up to 50 lbs regularly.<\/p>\n<p>- Ability to stand, walk, bend, or sit for extended periods.<\/p>\n<p>- Comfortable working in varying weather conditions (heat, cold, dust).<\/p>\n<p><br><\/p>\n<p>Compensation and Benefits:<\/p>\n<p>- Competitive hourly rate based on experience.<\/p>\n<p>- Potential for overtime based on project needs.<\/p>\n<p>- Accommodation assistance and travel arrangements if applicable.<\/p>\n<p>- Opportunity to gain experience with a reputable construction project in Nevada.<\/p>\n<p><br><\/p>\n<p>If you meet the qualifications and are interested in contributing to a dynamic team for a short-term contract position, please apply with your resume and relevant certifications. <\/p>\n<p>We look forward to hearing from you!<\/p>","post_title":"CAT D6 Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/cat-d6-dozer-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Wells","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Wells, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<p>Job Summary:<\/p>\n\n<p>We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in Wells, Nevada. The ideal candidate will have at least 5 years of experience operating CAT D6 Dozers, with a strong focus on safety, efficiency, and quality. This position requires a dedicated professional to perform a variety of tasks related to construction, earthmoving, and site preparation on a project site.<\/p>\n<p><br><\/p>\n<p>Key Responsibilities:<\/p>\n<p>- Operate a CAT D6 Dozer for a variety of tasks including grading, leveling, clearing, and trenching on construction sites.<\/p>\n<p>- Perform pre-operation inspections and basic maintenance on the CAT D6 Dozer to ensure safe and efficient operation.<\/p>\n<p>- Follow project specifications and plans to ensure proper execution of work according to safety standards.<\/p>\n<p>- Work collaboratively with other equipment operators, laborers, and supervisors to meet project goals and deadlines.<\/p>\n<p>- Adhere to safety protocols and contribute to maintaining a safe work environment.<\/p>\n<p>- Communicate effectively with the team to coordinate tasks and report any issues or delays.<\/p>\n<p>- Complete necessary documentation and reports related to equipment use, work hours, and materials.<\/p>\n<p>---<\/p>\n<p>Required Qualifications:<\/p>\n<p>- Minimum 5 years of experience operating a CAT D6 Dozer or similar equipment in construction or heavy equipment operations.<\/p>\n<p>- Proven ability to perform tasks such as grading, clearing, and leveling with a high degree of precision.<\/p>\n<p>- Strong knowledge of equipment safety procedures and standard operating practices.<\/p>\n<p>- Ability to read and interpret project plans, blueprints, and specifications.<\/p>\n<p>- Valid driver\u2019s license and clean driving record.<\/p>\n<p>- Ability to perform basic machine maintenance, including lubricating and servicing equipment.<\/p>\n<p>- Must pass a pre-employment drug screening and background check.<\/p><p><br><\/p>\n\n<p>Preferred Qualifications:<\/p>\n<p>- Experience working in remote locations or with short-term contract positions.<\/p>\n<p>- Knowledge of additional heavy equipment operations.<\/p><p><br><\/p>\n\n<p>Physical Requirements:<\/p>\n<p>- Ability to lift up to 50 lbs regularly.<\/p>\n<p>- Ability to stand, walk, bend, or sit for extended periods.<\/p>\n<p>- Comfortable working in varying weather conditions (heat, cold, dust).<\/p>\n<p><br><\/p>\n<p>Compensation and Benefits:<\/p>\n<p>- Competitive hourly rate based on experience.<\/p>\n<p>- Potential for overtime based on project needs.<\/p>\n<p>- Accommodation assistance and travel arrangements if applicable.<\/p>\n<p>- Opportunity to gain experience with a reputable construction project in Nevada.<\/p>\n<p><br><\/p>\n<p>If you meet the qualifications and are interested in contributing to a dynamic team for a short-term contract position, please apply with your resume and relevant certifications. <\/p>\n<p>We look forward to hearing from you!<\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/203ca195d849-cat-d6-dozer-operator","%breezy_id%":"203ca195d849","%breezy_friendly_id%":"203ca195d849-cat-d6-dozer-operator","%breezy_created_date%":"2025-02-28T19:02:42.109Z","%breezy_updated_date%":"2026-05-22T20:53:26.482Z","%_wpgmp_location_city%":"Wells","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wells, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.1115888","%_wpgmp_metabox_longitude%":"-114.96449","%rank_math_internal_links_processed%":"1"}},"id":3714,"infowindow_disable":false},{"source":"post","title":"Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: Turner Staffing Group is seeking a skilled and experienced Dozer Operator for a reputable mining company located in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: Turner Staffing Group is seeking a skilled and experienced Dozer Operator for a reputable mining company located in&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: Turner Staffing Group is seeking a skilled and experienced Dozer Operator for a reputable mining company located in&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>Turner Staffing Group is seeking a skilled and experienced <strong>Dozer Operator<\/strong> for a reputable mining company located in Pennsylvania. The Dozer Operator will be responsible for operating heavy dozers and related equipment to support mining operations in a surface mining setting. The ideal candidate will have experience in heavy equipment operation, particularly dozers, and be able to work efficiently in an outdoor, physically demanding environment.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Operate Dozers:<\/strong> Safely operate various dozers (D9, D10, D11, or similar) to perform tasks including grading, pushing, leveling, and clearing materials in a surface mining operation.<\/li><li><strong>Material Handling:<\/strong> Transport materials to designated areas, ensuring that the equipment is operated in compliance with project plans and specifications.<\/li><li><strong>Worksite Safety:<\/strong> Follow all safety protocols and company guidelines to ensure a safe working environment for yourself and others. Adhere to OSHA and MSHA regulations.<\/li><li><strong>Equipment Care:<\/strong> Perform routine maintenance checks on dozers and other heavy equipment, including checking fluid levels, tire pressure, and general machine function. Report any mechanical issues or concerns to the equipment maintenance team.<\/li><li><strong>Collaboration:<\/strong> Work closely with other operators, ground crew, and supervisors to ensure smooth operations and efficient progress of mining activities.<\/li><li><strong>Weather and Terrain Adaptability:<\/strong> Able to work in various weather conditions and on rough, uneven terrain typical of surface mining operations.<\/li><li><strong>Documentation:<\/strong> Maintain accurate records of work performed, including daily logs and any issues or maintenance required on equipment.<\/li><\/ul>\n<p><\/p>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul><li><strong>Experience:<\/strong> Minimum of 2-3 years operating dozers in a mining, construction, or similar heavy equipment environment.<\/li><li><strong>Skills:<\/strong><ul><li>Proficient in operating dozers and similar heavy machinery in a mining environment.<\/li><li>Ability to perform routine maintenance and troubleshooting of heavy equipment.<\/li><li>Strong knowledge of safety standards and best practices in a mining or construction setting.<\/li><\/ul><\/li><li><strong>Physical Requirements:<\/strong> Ability to perform physically demanding tasks, including operating heavy machinery for extended periods and working in harsh weather conditions.<\/li><\/ul>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"TSG","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>Turner Staffing Group is seeking a skilled and experienced <strong>Dozer Operator<\/strong> for a reputable mining company located in Pennsylvania. The Dozer Operator will be responsible for operating heavy dozers and related equipment to support mining operations in a surface mining setting. The ideal candidate will have experience in heavy equipment operation, particularly dozers, and be able to work efficiently in an outdoor, physically demanding environment.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Operate Dozers:<\/strong> Safely operate various dozers (D9, D10, D11, or similar) to perform tasks including grading, pushing, leveling, and clearing materials in a surface mining operation.<\/li><li><strong>Material Handling:<\/strong> Transport materials to designated areas, ensuring that the equipment is operated in compliance with project plans and specifications.<\/li><li><strong>Worksite Safety:<\/strong> Follow all safety protocols and company guidelines to ensure a safe working environment for yourself and others. Adhere to OSHA and MSHA regulations.<\/li><li><strong>Equipment Care:<\/strong> Perform routine maintenance checks on dozers and other heavy equipment, including checking fluid levels, tire pressure, and general machine function. Report any mechanical issues or concerns to the equipment maintenance team.<\/li><li><strong>Collaboration:<\/strong> Work closely with other operators, ground crew, and supervisors to ensure smooth operations and efficient progress of mining activities.<\/li><li><strong>Weather and Terrain Adaptability:<\/strong> Able to work in various weather conditions and on rough, uneven terrain typical of surface mining operations.<\/li><li><strong>Documentation:<\/strong> Maintain accurate records of work performed, including daily logs and any issues or maintenance required on equipment.<\/li><\/ul>\n<p><\/p>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul><li><strong>Experience:<\/strong> Minimum of 2-3 years operating dozers in a mining, construction, or similar heavy equipment environment.<\/li><li><strong>Skills:<\/strong><ul><li>Proficient in operating dozers and similar heavy machinery in a mining environment.<\/li><li>Ability to perform routine maintenance and troubleshooting of heavy equipment.<\/li><li>Strong knowledge of safety standards and best practices in a mining or construction setting.<\/li><\/ul><\/li><li><strong>Physical Requirements:<\/strong> Ability to perform physically demanding tasks, including operating heavy machinery for extended periods and working in harsh weather conditions.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ed543c58aa22-dozer-operator","%breezy_id%":"ed543c58aa22","%breezy_friendly_id%":"ed543c58aa22-dozer-operator","%breezy_created_date%":"2024-11-11T21:54:27.413Z","%breezy_updated_date%":"2026-05-22T20:49:36.962Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":3713,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-3\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-3\/","zoom":19,"extra_fields":{"post_excerpt":"About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment&hellip;","post_content":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong><br>We are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"TSG","%description%":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong><br>We are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3cc09490897f-heavy-equipment-operator","%breezy_id%":"3cc09490897f","%breezy_friendly_id%":"3cc09490897f-heavy-equipment-operator","%breezy_created_date%":"2024-11-11T21:32:36.264Z","%breezy_updated_date%":"2026-05-22T20:49:03.209Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":3712,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Us:Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-4\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Us:Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"About Us:Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud&hellip;","post_content":"<p><strong>About Us:<\/strong><br>Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Bowmansville, Pennsylvania. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Bowmansville, Pennsylvania. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong>&nbsp;Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong>&nbsp;Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong>&nbsp;Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong>&nbsp;Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong>&nbsp;Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong>&nbsp;Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"TSG","%description%":"<p><strong>About Us:<\/strong><br>Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Bowmansville, Pennsylvania. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Bowmansville, Pennsylvania. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong>&nbsp;Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong>&nbsp;Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong>&nbsp;Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong>&nbsp;Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong>&nbsp;Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong>&nbsp;Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/557ad6ff5763-excavator-operator","%breezy_id%":"557ad6ff5763","%breezy_friendly_id%":"557ad6ff5763-excavator-operator","%breezy_created_date%":"2024-11-11T21:22:05.636Z","%breezy_updated_date%":"2026-05-22T20:50:48.144Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":3711,"infowindow_disable":false},{"source":"post","title":"Paving Screed Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Screed Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-screed-operator-2\/\" name=\"Paving Screed Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt&hellip;","address":"Reading, PA, USA","location":{"lat":"40.3369615","city":"Reading","state":"PA","country":"United States","lng":"-75.9214385","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-screed-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt&hellip;","post_content":"<p>Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt paving machine to ensure a smooth, even, and properly compacted surface. This role requires precision, attention to detail, and coordination with the paving crew to meet project specifications and quality standards.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Operate the screed controls on an asphalt paver to regulate depth, width, and smoothness of the asphalt mat<\/li>\n<li>Adjust screed settings to maintain proper grade, slope, and crown according to project plans<\/li>\n<li>Monitor asphalt material flow and temperature to ensure consistent paving quality<\/li>\n<li>Coordinate with the paver operator, roller operators, and ground crew for efficient workflow<\/li>\n<li>Perform routine checks and minor maintenance on screed equipment<\/li>\n<li>Identify and correct surface irregularities during paving operations<\/li>\n<li>Ensure compliance with safety regulations and company policies<\/li>\n<li>Read and interpret project plans, grade stakes, and specifications<\/li>\n<li>Maintain a safe and clean work environment<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>High school diploma or equivalent preferred<\/li>\n<li>2+ years of experience operating paving equipment, specifically screeds<\/li>\n<li>Strong understanding of asphalt paving processes and materials<\/li>\n<li>Ability to read grade stakes, blueprints, and layout drawings<\/li>\n<li>Valid driver\u2019s license (CDL preferred but not always required)<\/li>\n<\/ul>\n<h2><strong>Skills &amp; Competencies<\/strong><\/h2>\n<ul>\n<li>Attention to detail and precision in equipment operation<\/li>\n<li>Strong hand-eye coordination<\/li>\n<li>Ability to work effectively in a team environment<\/li>\n<li>Good communication and problem-solving skills<\/li>\n<li>Mechanical aptitude for equipment troubleshooting<\/li>\n<li>Ability to work in varying weather conditions<\/li>\n<\/ul>\n<h2><strong>Physical Requirements<\/strong><\/h2>\n<ul>\n<li>Ability to stand for long periods and work on uneven surfaces<\/li>\n<li>Frequently lift up to 50 lbs<\/li>\n<li>Ability to work outdoors in hot, cold, and noisy environments<\/li>\n<li>Must be able to bend, stoop, and climb onto equipment<\/li>\n<\/ul>\n<p><\/p>\n<p>This role is based in Bowmansville, PA and is an on-site role.<\/p>","post_title":"Paving Screed Operator","post_link":"https:\/\/turnerstaffing.com\/position\/paving-screed-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Reading","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Reading, PA","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p>Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt paving machine to ensure a smooth, even, and properly compacted surface. This role requires precision, attention to detail, and coordination with the paving crew to meet project specifications and quality standards.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Operate the screed controls on an asphalt paver to regulate depth, width, and smoothness of the asphalt mat<\/li>\n<li>Adjust screed settings to maintain proper grade, slope, and crown according to project plans<\/li>\n<li>Monitor asphalt material flow and temperature to ensure consistent paving quality<\/li>\n<li>Coordinate with the paver operator, roller operators, and ground crew for efficient workflow<\/li>\n<li>Perform routine checks and minor maintenance on screed equipment<\/li>\n<li>Identify and correct surface irregularities during paving operations<\/li>\n<li>Ensure compliance with safety regulations and company policies<\/li>\n<li>Read and interpret project plans, grade stakes, and specifications<\/li>\n<li>Maintain a safe and clean work environment<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>High school diploma or equivalent preferred<\/li>\n<li>2+ years of experience operating paving equipment, specifically screeds<\/li>\n<li>Strong understanding of asphalt paving processes and materials<\/li>\n<li>Ability to read grade stakes, blueprints, and layout drawings<\/li>\n<li>Valid driver\u2019s license (CDL preferred but not always required)<\/li>\n<\/ul>\n<h2><strong>Skills &amp; Competencies<\/strong><\/h2>\n<ul>\n<li>Attention to detail and precision in equipment operation<\/li>\n<li>Strong hand-eye coordination<\/li>\n<li>Ability to work effectively in a team environment<\/li>\n<li>Good communication and problem-solving skills<\/li>\n<li>Mechanical aptitude for equipment troubleshooting<\/li>\n<li>Ability to work in varying weather conditions<\/li>\n<\/ul>\n<h2><strong>Physical Requirements<\/strong><\/h2>\n<ul>\n<li>Ability to stand for long periods and work on uneven surfaces<\/li>\n<li>Frequently lift up to 50 lbs<\/li>\n<li>Ability to work outdoors in hot, cold, and noisy environments<\/li>\n<li>Must be able to bend, stoop, and climb onto equipment<\/li>\n<\/ul>\n<p><\/p>\n<p>This role is based in Bowmansville, PA and is an on-site role.<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/1335218e221a-paving-screed-operator","%breezy_id%":"1335218e221a","%breezy_friendly_id%":"1335218e221a-paving-screed-operator","%breezy_created_date%":"2026-05-21T19:28:37.102Z","%breezy_updated_date%":"2026-05-21T19:28:48.805Z","%_wpgmp_location_city%":"Reading","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Reading, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.3369615","%_wpgmp_metabox_longitude%":"-75.9214385","%rank_math_internal_links_processed%":"1"}},"id":3710,"infowindow_disable":false},{"source":"post","title":"General Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are seeking a hardworking and safety-conscious Groundman \/ General Laborer to assist with site operations focused in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-laborer\/\" name=\"General Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are seeking a hardworking and safety-conscious Groundman \/ General Laborer to assist with site operations focused in&hellip;","address":"Winston-Salem, NC, USA","location":{"lat":"36.0948221","city":"Winston-Salem","state":"NC","country":"United States","lng":"-80.2434028","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are seeking a hardworking and safety-conscious Groundman \/ General Laborer to assist with site operations focused in&hellip;","post_content":"<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking a hardworking and safety-conscious <strong>Groundman \/ General Laborer<\/strong> to assist with site operations focused in stream restoration work.&nbsp;The ideal candidate will have hands-on experience operating chainsaws and other hand tools, with the ability to support daily field activities efficiently and safely. Experience operating track trucks or mini excavators is a <strong>plus<\/strong>, but not required.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform general labor duties to support site operations and crews.<\/p>\n<\/li>\n<li>\n<p>Safely operate and maintain chainsaws and other hand tools for clearing, cutting, or ground work.<\/p>\n<\/li>\n<li>\n<p>Assist with loading, unloading, and moving materials and equipment.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area.<\/p>\n<\/li>\n<li>\n<p>Follow safety procedures and report any hazards or incidents to the supervisor.<\/p>\n<\/li>\n<li>\n<p>Support equipment operators and crew members as directed.<\/p><\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous experience in a general labor, construction, or site support role preferred.<\/p>\n<\/li>\n<li>\n<p>Experience with <strong>chainsaws and other hand tools<\/strong> required.<\/p>\n<\/li>\n<li>\n<p>Experience operating <strong>track trucks or mini excavators<\/strong> is a <strong>plus<\/strong>, but not mandatory.<\/p>\n<\/li>\n<li>\n<p>Ability to perform physically demanding tasks in various weather conditions.<\/p>\n<\/li>\n<li>\n<p>Reliable transportation and punctuality are required.<\/p>\n<\/li>\n<li>\n<p>Must adhere to all company safety policies and procedures<\/p><\/li><\/ul>","post_title":"General Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Winston-Salem","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Winston-Salem, NC","%education%":"","%department%":"TSG","%description%":"<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking a hardworking and safety-conscious <strong>Groundman \/ General Laborer<\/strong> to assist with site operations focused in stream restoration work.&nbsp;The ideal candidate will have hands-on experience operating chainsaws and other hand tools, with the ability to support daily field activities efficiently and safely. Experience operating track trucks or mini excavators is a <strong>plus<\/strong>, but not required.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform general labor duties to support site operations and crews.<\/p>\n<\/li>\n<li>\n<p>Safely operate and maintain chainsaws and other hand tools for clearing, cutting, or ground work.<\/p>\n<\/li>\n<li>\n<p>Assist with loading, unloading, and moving materials and equipment.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area.<\/p>\n<\/li>\n<li>\n<p>Follow safety procedures and report any hazards or incidents to the supervisor.<\/p>\n<\/li>\n<li>\n<p>Support equipment operators and crew members as directed.<\/p><\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous experience in a general labor, construction, or site support role preferred.<\/p>\n<\/li>\n<li>\n<p>Experience with <strong>chainsaws and other hand tools<\/strong> required.<\/p>\n<\/li>\n<li>\n<p>Experience operating <strong>track trucks or mini excavators<\/strong> is a <strong>plus<\/strong>, but not mandatory.<\/p>\n<\/li>\n<li>\n<p>Ability to perform physically demanding tasks in various weather conditions.<\/p>\n<\/li>\n<li>\n<p>Reliable transportation and punctuality are required.<\/p>\n<\/li>\n<li>\n<p>Must adhere to all company safety policies and procedures<\/p><\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/7759a8aff717-general-laborer","%breezy_id%":"7759a8aff717","%breezy_friendly_id%":"7759a8aff717-general-laborer","%breezy_created_date%":"2026-05-21T16:05:48.989Z","%breezy_updated_date%":"2026-05-21T16:06:26.508Z","%_wpgmp_location_city%":"Winston-Salem","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winston-Salem, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.0948221","%_wpgmp_metabox_longitude%":"-80.2434028","%rank_math_internal_links_processed%":"1"}},"id":3709,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are actively seeking a Excavator Operator to work with us in the Winston-Salem, NC area to support stream restoration&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-3\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are actively seeking a Excavator Operator to work with us in the Winston-Salem, NC area to support stream restoration&hellip;","address":"Winston-Salem, NC, USA","location":{"lat":"36.0948221","city":"Winston-Salem","state":"NC","country":"United States","lng":"-80.2434028","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-3\/","zoom":19,"extra_fields":{"post_excerpt":"We are actively seeking a Excavator Operator to work with us in the Winston-Salem, NC area to support stream restoration&hellip;","post_content":"<p>We are actively seeking a Excavator Operator to work with us in the Winston-Salem, NC area to support stream restoration projects.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors and teammates<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Willingness to travel out of state.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators<\/li><li>GPS System experience required&nbsp;<\/li><li>Ability to read and understand grade stakes.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Winston-Salem","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Winston-Salem, NC","%education%":"","%department%":"TSG","%description%":"<p>We are actively seeking a Excavator Operator to work with us in the Winston-Salem, NC area to support stream restoration projects.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors and teammates<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Willingness to travel out of state.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators<\/li><li>GPS System experience required&nbsp;<\/li><li>Ability to read and understand grade stakes.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/39d00e87b9a8-excavator-operator","%breezy_id%":"39d00e87b9a8","%breezy_friendly_id%":"39d00e87b9a8-excavator-operator","%breezy_created_date%":"2026-05-21T16:03:13.315Z","%breezy_updated_date%":"2026-05-21T16:03:28.150Z","%_wpgmp_location_city%":"Winston-Salem","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winston-Salem, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.0948221","%_wpgmp_metabox_longitude%":"-80.2434028","%rank_math_internal_links_processed%":"1"}},"id":3708,"infowindow_disable":false},{"source":"post","title":"Foreman &#8211; Mining\/Civil","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Foreman &#8211; Mining\/Civil\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/foreman-mining-civil\/\" name=\"Foreman &#8211; Mining\/Civil\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising&hellip;","address":"Houston, TX, USA","location":{"lat":"29.7600771","city":"Houston","state":"TX","country":"United States","lng":"-95.3701108","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/foreman-mining-civil\/","zoom":19,"extra_fields":{"post_excerpt":"We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising&hellip;","post_content":"<p><u>We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment<\/u><\/p>\n<p><strong><u><br><\/u><\/strong><\/p>\n<p><strong><u>Position Summary<\/u><\/strong><\/p>\n<p><strong><u><\/u><\/strong><u>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/u><\/p>\n<p><\/p>\n<p><u><\/u><strong><u>Key Responsibilities<\/u><\/strong><\/p>\n<ul><li>Supervise and direct daily activities of mining crews, equipment operators, and labor personnel<\/li><li>Coordinate production schedules to meet daily and weekly output targets<\/li><li>Monitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures<\/li><li>Enforce mine safety standards, company policies, and MSHA regulations at all times<\/li><li>Conduct pre-shift meetings, safety briefings, and crew assignments<\/li><li>Inspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies<\/li><li>Communicate with management regarding production progress, staffing needs, and operational concerns<\/li><li>Ensure equipment is being operated properly and maintenance issues are reported promptly<\/li><li>Train and mentor crew members on safe work practices and operational procedures<\/li><li>Maintain accurate shift reports, production logs, and incident documentation<\/li><\/ul>\n<p><strong><u>Qualifications<\/u><\/strong><\/p>\n<ul><li>Previous supervisory experience in mining operations required<\/li><li>Strong knowledge of surface or underground mining processes (depending on site application)<\/li><li>Experience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers<\/li><li>MSHA certification required or ability to obtain\/maintain certification as required by site<\/li><li>Proven leadership, communication, and decision-making skills<\/li><li>Ability to prioritize tasks and manage multiple crews in a fast-paced environment<\/li><li>Strong understanding of workplace safety and hazard recognition practices<\/li><li>Proficient in basic reporting, documentation, and production tracking<\/li><\/ul>\n<p><strong><u>Physical Requirements<\/u><\/strong><\/p>\n<ul><li>Ability to work in active mining environments, including exposure to dust, noise, and varying weather conditions<\/li><li>Ability to walk uneven terrain, climb equipment\/access points, and remain active throughout shift<\/li><li>Ability to lift up to 50 pounds occasionally<\/li><li>Must be able to wear all required PPE on site<\/li><\/ul>","post_title":"Foreman &#8211; Mining\/Civil","post_link":"https:\/\/turnerstaffing.com\/position\/foreman-mining-civil\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Houston","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Houston, TX","%education%":"","%department%":"TSG","%description%":"<p><u>We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment<\/u><\/p>\n<p><strong><u><br><\/u><\/strong><\/p>\n<p><strong><u>Position Summary<\/u><\/strong><\/p>\n<p><strong><u><\/u><\/strong><u>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/u><\/p>\n<p><\/p>\n<p><u><\/u><strong><u>Key Responsibilities<\/u><\/strong><\/p>\n<ul><li>Supervise and direct daily activities of mining crews, equipment operators, and labor personnel<\/li><li>Coordinate production schedules to meet daily and weekly output targets<\/li><li>Monitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures<\/li><li>Enforce mine safety standards, company policies, and MSHA regulations at all times<\/li><li>Conduct pre-shift meetings, safety briefings, and crew assignments<\/li><li>Inspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies<\/li><li>Communicate with management regarding production progress, staffing needs, and operational concerns<\/li><li>Ensure equipment is being operated properly and maintenance issues are reported promptly<\/li><li>Train and mentor crew members on safe work practices and operational procedures<\/li><li>Maintain accurate shift reports, production logs, and incident documentation<\/li><\/ul>\n<p><strong><u>Qualifications<\/u><\/strong><\/p>\n<ul><li>Previous supervisory experience in mining operations required<\/li><li>Strong knowledge of surface or underground mining processes (depending on site application)<\/li><li>Experience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers<\/li><li>MSHA certification required or ability to obtain\/maintain certification as required by site<\/li><li>Proven leadership, communication, and decision-making skills<\/li><li>Ability to prioritize tasks and manage multiple crews in a fast-paced environment<\/li><li>Strong understanding of workplace safety and hazard recognition practices<\/li><li>Proficient in basic reporting, documentation, and production tracking<\/li><\/ul>\n<p><strong><u>Physical Requirements<\/u><\/strong><\/p>\n<ul><li>Ability to work in active mining environments, including exposure to dust, noise, and varying weather conditions<\/li><li>Ability to walk uneven terrain, climb equipment\/access points, and remain active throughout shift<\/li><li>Ability to lift up to 50 pounds occasionally<\/li><li>Must be able to wear all required PPE on site<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ccd597836618-foreman-mining-civil","%breezy_id%":"ccd597836618","%breezy_friendly_id%":"ccd597836618-foreman-mining-civil","%breezy_created_date%":"2026-04-20T19:07:01.009Z","%breezy_updated_date%":"2026-05-21T15:04:06.699Z","%_wpgmp_location_city%":"Houston","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Houston, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.7600771","%_wpgmp_metabox_longitude%":"-95.3701108","%rank_math_internal_links_processed%":"1"}},"id":3706,"infowindow_disable":false},{"source":"post","title":"Supply Chain Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Supply Chain Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is looking for a&nbsp;Supply Chain Manager plays a key role in supporting safe, reliable operations by leading all&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/supply-chain-manager\/\" name=\"Supply Chain Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is looking for a&nbsp;Supply Chain Manager plays a key role in supporting safe, reliable operations by leading all&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/supply-chain-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is looking for a&nbsp;Supply Chain Manager plays a key role in supporting safe, reliable operations by leading all&hellip;","post_content":"<p>Our client is looking for a&nbsp;<strong>Supply Chain Manager<\/strong> plays a key role in supporting safe, reliable operations by leading all site supply chain activities, including procurement, inventory management, warehousing, and logistics. This position focuses on ensuring the right materials and services are available at the right time while maintaining strong cost control and operational discipline.<\/p>\n<p>In close partnership with Maintenance, Operations, Finance, and corporate teams, the Supply Chain Manager works to strengthen supplier relationships, improve planning and execution, and drive continuous improvement across the supply chain.<\/p>\n<h3>What You\u2019ll Do<\/h3>\n<ul>\n<li>Lead and oversee site procurement, inventory, warehousing, and logistics activities<\/li>\n<li>Build strong relationships with suppliers and manage contracts, performance, and costs<\/li>\n<li>Ensure timely, cost\u2011effective purchasing of materials, equipment, and services<\/li>\n<li>Optimize inventory levels to support operations and maintenance while managing working capital<\/li>\n<li>Use data, KPIs, and ERP systems (e.g., SAP) to improve efficiency and decision\u2011making<\/li>\n<li>Support budgeting, forecasting, and cost management efforts<\/li>\n<li>Coach and develop the supply chain team while promoting a culture of safety, accountability, and continuous improvement<\/li>\n<\/ul>\n<h3>What We\u2019re Looking For<\/h3>\n<ul>\n<li>Bachelor\u2019s degree in Supply Chain, Business, or a related field (or equivalent experience)<\/li>\n<li>7\u201310+ years of experience in supply chain, procurement, or materials management, ideally in a mining or heavy industrial environment<\/li>\n<li>Experience managing procurement, inventory, and logistics in a complex operation<\/li>\n<li>Strong leadership, communication, and problem\u2011solving skills<\/li>\n<li>Working knowledge of ERP systems and supply chain best practices<\/li>\n<li>A strong commitment to safety and operational excellence<\/li><\/ul><p><\/p>","post_title":"Supply Chain Manager","post_link":"https:\/\/turnerstaffing.com\/position\/supply-chain-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Bachelor's Degree","%department%":"TSG","%description%":"<p>Our client is looking for a&nbsp;<strong>Supply Chain Manager<\/strong> plays a key role in supporting safe, reliable operations by leading all site supply chain activities, including procurement, inventory management, warehousing, and logistics. This position focuses on ensuring the right materials and services are available at the right time while maintaining strong cost control and operational discipline.<\/p>\n<p>In close partnership with Maintenance, Operations, Finance, and corporate teams, the Supply Chain Manager works to strengthen supplier relationships, improve planning and execution, and drive continuous improvement across the supply chain.<\/p>\n<h3>What You\u2019ll Do<\/h3>\n<ul>\n<li>Lead and oversee site procurement, inventory, warehousing, and logistics activities<\/li>\n<li>Build strong relationships with suppliers and manage contracts, performance, and costs<\/li>\n<li>Ensure timely, cost\u2011effective purchasing of materials, equipment, and services<\/li>\n<li>Optimize inventory levels to support operations and maintenance while managing working capital<\/li>\n<li>Use data, KPIs, and ERP systems (e.g., SAP) to improve efficiency and decision\u2011making<\/li>\n<li>Support budgeting, forecasting, and cost management efforts<\/li>\n<li>Coach and develop the supply chain team while promoting a culture of safety, accountability, and continuous improvement<\/li>\n<\/ul>\n<h3>What We\u2019re Looking For<\/h3>\n<ul>\n<li>Bachelor\u2019s degree in Supply Chain, Business, or a related field (or equivalent experience)<\/li>\n<li>7\u201310+ years of experience in supply chain, procurement, or materials management, ideally in a mining or heavy industrial environment<\/li>\n<li>Experience managing procurement, inventory, and logistics in a complex operation<\/li>\n<li>Strong leadership, communication, and problem\u2011solving skills<\/li>\n<li>Working knowledge of ERP systems and supply chain best practices<\/li>\n<li>A strong commitment to safety and operational excellence<\/li><\/ul><p><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ec9ec1a63a73-supply-chain-manager","%breezy_id%":"ec9ec1a63a73","%breezy_friendly_id%":"ec9ec1a63a73-supply-chain-manager","%breezy_created_date%":"2026-04-08T21:11:10.732Z","%breezy_updated_date%":"2026-05-21T14:51:05.393Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":3705,"infowindow_disable":false},{"source":"post","title":"Senior Mining Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Mining Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: Reporting to the Chief Engineer, the Senior Mining Engineer plays a vital part in leading and supporting the&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-mining-engineer\/\" name=\"Senior Mining Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: Reporting to the Chief Engineer, the Senior Mining Engineer plays a vital part in leading and supporting the&hellip;","address":"Brawley, CA, USA","location":{"lat":"32.9786566","city":"Brawley","state":"CA","country":"United States","lng":"-115.530267","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-mining-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: Reporting to the Chief Engineer, the Senior Mining Engineer plays a vital part in leading and supporting the&hellip;","post_content":"<p><strong>Job Summary:<\/strong><\/p>\n<p>Reporting to the Chief Engineer, the Senior Mining Engineer plays a vital part in leading and supporting the engineering and survey teams.  The successful candidate will drive the development, planning and execution of the mine, and be a key factor between the long-term and short-term planning functions.<\/p>\n<p><strong>Primary Duties &amp; Responsibilities:<\/strong><\/p>\n<p>Health and Safety<\/p>\n<ul>\n <li>Knows responsibilities related to the Emergency Response Plan      (ERP)<\/li>\n <li>Learns and administers all company and legislated policies and      procedures<\/li>\n <li>Contributes to the department\u2019s health and safety goals and      objectives<\/li>\n <li>Responds to safety concerns and\/or unsafe conditions, and takes      corrective action, or seeks assistance in doing so<\/li>\n<\/ul>\n<p>Environment<\/p>\n<ul>\n <li>Knows responsibilities related to the Environmental Management      System (EMS)<\/li>\n <li>Contributes to the department\u2019s environmental goals and objectives<\/li>\n <li>Ensures department activities prevent or mitigate the effects of      pollution<\/li>\n <li>Responds to environmental concerns and takes corrective action, or      seeks assistance  in doing so<\/li>\n <li>Follows company standards and guidelines for spill reporting and      response<\/li>\n<\/ul>\n<p>Departmental<\/p>\n<ul>\n <li>Utilizes planning software for mine design, mine planning, dump and      leach pad design.<\/li>\n <li>Utilizes planning software to estimate economic pit shells for      design and reporting reserves\/resources.<\/li>\n <li>Identify planning and operational constraints during the business      planning cycle.<\/li>\n <li>Create, review and evaluate life of mine plans during the yearly      business planning cycle.<\/li>\n <li>Review and understand yearly cost variances for the business      planning cycle.<\/li>\n <li>Leads engineering projects related to the mine\/company.<\/li>\n <li>Reviews and reports end of month production statistics and reconcile      actual vs budget variations.<\/li>\n <li>Assist with daily reporting and production communication to ensure      mine plans are being followed.<\/li>\n <li>Assist and provide mentorship to junior engineers.<\/li>\n <li>Keeps up with current trends related to mine design software and      integrates this information into work assignments and methodology.<\/li>\n <li>Maintains effective communication between departments.<\/li>\n <li>Knowledge of block model coding to assist with model manipulation      for engineering variables.<\/li>\n <li>Assist in reclamation planning as needed. <\/li>\n <li>Assist with daily reporting and production communication to ensure      mine plans are being followed.<\/li>\n <li>Assist and provide mentorship to junior engineers.<\/li>\n <li>Keeps up with current trends related to mine design software and      integrates this information into work assignments and methodology.<\/li>\n <li>Maintains effective communication between departments.<\/li>\n <li>Knowledge of block model coding to assist with model manipulation      for engineering variables.<\/li>\n <li>Assist in reclamation planning as needed.<\/li>\n<\/ul>\n<p>Cost Control &amp; Communication <\/p>\n<ul>\n <li>Manages spending within approved budget<\/li>\n <li>Maintains effective information exchange with relevant departments<\/li>\n<\/ul>\n<p><strong>Knowledge, Skill and Experience:<\/strong><\/p>\n<ul>\n <li>Bachelor\u2019s degree in mining engineering or Relevant Experience<\/li>\n <li>7+ years of mining experience, preferably in conventional      truck\/shovel open pit operation<\/li>\n <li>Working knowledge of Mine Plan preferred<\/li>\n <li>Working knowledge of survey equipment<\/li>\n <li>Attention to detail with excellent organizational skills<\/li>\n <li>Ability to identify, analyze and solve problems<\/li>\n <li>Ability to prepare accurate records and reports<\/li>\n <li>Excellent oral and written communication skills with internal and      external contacts<\/li>\n <li>MS Office Suite<\/li>\n<\/ul>","post_title":"Senior Mining Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/senior-mining-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Brawley","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Brawley, CA","%education%":"","%department%":"TSG","%description%":"<p><strong>Job Summary:<\/strong><\/p>\n<p>Reporting to the Chief Engineer, the Senior Mining Engineer plays a vital part in leading and supporting the engineering and survey teams.  The successful candidate will drive the development, planning and execution of the mine, and be a key factor between the long-term and short-term planning functions.<\/p>\n<p><strong>Primary Duties &amp; Responsibilities:<\/strong><\/p>\n<p>Health and Safety<\/p>\n<ul>\n <li>Knows responsibilities related to the Emergency Response Plan      (ERP)<\/li>\n <li>Learns and administers all company and legislated policies and      procedures<\/li>\n <li>Contributes to the department\u2019s health and safety goals and      objectives<\/li>\n <li>Responds to safety concerns and\/or unsafe conditions, and takes      corrective action, or seeks assistance in doing so<\/li>\n<\/ul>\n<p>Environment<\/p>\n<ul>\n <li>Knows responsibilities related to the Environmental Management      System (EMS)<\/li>\n <li>Contributes to the department\u2019s environmental goals and objectives<\/li>\n <li>Ensures department activities prevent or mitigate the effects of      pollution<\/li>\n <li>Responds to environmental concerns and takes corrective action, or      seeks assistance  in doing so<\/li>\n <li>Follows company standards and guidelines for spill reporting and      response<\/li>\n<\/ul>\n<p>Departmental<\/p>\n<ul>\n <li>Utilizes planning software for mine design, mine planning, dump and      leach pad design.<\/li>\n <li>Utilizes planning software to estimate economic pit shells for      design and reporting reserves\/resources.<\/li>\n <li>Identify planning and operational constraints during the business      planning cycle.<\/li>\n <li>Create, review and evaluate life of mine plans during the yearly      business planning cycle.<\/li>\n <li>Review and understand yearly cost variances for the business      planning cycle.<\/li>\n <li>Leads engineering projects related to the mine\/company.<\/li>\n <li>Reviews and reports end of month production statistics and reconcile      actual vs budget variations.<\/li>\n <li>Assist with daily reporting and production communication to ensure      mine plans are being followed.<\/li>\n <li>Assist and provide mentorship to junior engineers.<\/li>\n <li>Keeps up with current trends related to mine design software and      integrates this information into work assignments and methodology.<\/li>\n <li>Maintains effective communication between departments.<\/li>\n <li>Knowledge of block model coding to assist with model manipulation      for engineering variables.<\/li>\n <li>Assist in reclamation planning as needed. <\/li>\n <li>Assist with daily reporting and production communication to ensure      mine plans are being followed.<\/li>\n <li>Assist and provide mentorship to junior engineers.<\/li>\n <li>Keeps up with current trends related to mine design software and      integrates this information into work assignments and methodology.<\/li>\n <li>Maintains effective communication between departments.<\/li>\n <li>Knowledge of block model coding to assist with model manipulation      for engineering variables.<\/li>\n <li>Assist in reclamation planning as needed.<\/li>\n<\/ul>\n<p>Cost Control &amp; Communication <\/p>\n<ul>\n <li>Manages spending within approved budget<\/li>\n <li>Maintains effective information exchange with relevant departments<\/li>\n<\/ul>\n<p><strong>Knowledge, Skill and Experience:<\/strong><\/p>\n<ul>\n <li>Bachelor\u2019s degree in mining engineering or Relevant Experience<\/li>\n <li>7+ years of mining experience, preferably in conventional      truck\/shovel open pit operation<\/li>\n <li>Working knowledge of Mine Plan preferred<\/li>\n <li>Working knowledge of survey equipment<\/li>\n <li>Attention to detail with excellent organizational skills<\/li>\n <li>Ability to identify, analyze and solve problems<\/li>\n <li>Ability to prepare accurate records and reports<\/li>\n <li>Excellent oral and written communication skills with internal and      external contacts<\/li>\n <li>MS Office Suite<\/li>\n<\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/9ea5d788a002-senior-mining-engineer","%breezy_id%":"9ea5d788a002","%breezy_friendly_id%":"9ea5d788a002-senior-mining-engineer","%breezy_created_date%":"2026-05-14T16:32:18.936Z","%breezy_updated_date%":"2026-05-21T15:08:06.226Z","%_wpgmp_location_city%":"Brawley","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Brawley, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.9786566","%_wpgmp_metabox_longitude%":"-115.530267","%rank_math_internal_links_processed%":"1"}},"id":3707,"infowindow_disable":false},{"source":"post","title":"Business Development Representative","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Business Development Representative\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Business Development Identify and pursue new clients and project opportunities within target markets Track and manage leads, opportunities, and client&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/business-development-representative\/\" name=\"Business Development Representative\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Business Development Identify and pursue new clients and project opportunities within target markets Track and manage leads, opportunities, and client&hellip;","address":"North Salt Lake, UT, USA","location":{"lat":"40.8485564","city":"North Salt Lake","state":"UT","country":"United States","lng":"-111.9068824","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/business-development-representative\/","zoom":19,"extra_fields":{"post_excerpt":"Business Development Identify and pursue new clients and project opportunities within target markets Track and manage leads, opportunities, and client&hellip;","post_content":"<p>Business Development<\/p>\n<ul><li>Identify and pursue new clients and project opportunities within target markets<\/li><li>Track and manage leads, opportunities, and client interactions<\/li><li>Attend industry events, networking opportunities, and client meetings to expand REDD Engineering\u2019s presence<\/li><\/ul>\n<p><\/p>\n<p>Relationship Development<\/p>\n<ul><li>Build and maintain relationships with industrial clients and key decision-makers<\/li><li>Regularly visit client facilities and job sites (anticipated travel ~30% depending on company and client needs)<\/li><li>Serve as a primary point of contact for new project opportunities and client inquiries<\/li><\/ul>\n<p><\/p>\n<p>Strategic Planning<\/p>\n<ul><li>Analyze market conditions, client activity, project cycles, and internal staffing levels to determine which clients and prospects to engage and when in collaboration with Business Development team, Business Manager, and Production Manager<\/li><li>Develop targeted outreach strategies aligned with anticipated project timelines, client decision windows, and projected fluctuations in company workload<\/li><li>Collaborate with the Business Development team, Production Manager, and Business Manager to align pursuits with company capacity and strategic priorities<\/li><\/ul>\n<p><\/p>\n<p>Proposal Development<\/p>\n<ul><li>Coordinate the end-to-end process for RFPs, RFQs, and other client solicitations from kickoff through final delivery<\/li><li>Lead the preparation of proposals and qualifications packages<\/li><li>Work with engineering\/design staff to define project scope, approach, and fee estimates<\/li><li>Coordinate with subconsultants and subcontractors to assemble project pricing<\/li><\/ul>\n<p><\/p>\n<p>Project Initiation<\/p>\n<ul><li>Support the transition of awarded projects to internal project teams<\/li><li>Assist with early project planning and client coordination to ensure a smooth kickoff<\/li><\/ul>\n<p><\/p>\n<p>Department Development<\/p>\n<ul><li>Develop and maintain business development resources including presentations and marketing materials<\/li><li>Maintain accurate documentation in the company CRM to support opportunity tracking, client history, and market intelligence<\/li><li>Document client feedback, relationship insights, and market observations to strengthen institutional knowledge and future pursuits<\/li><li>Prepare reports and summaries for company leadership to help assess business development performance, market trends, and strategy effectiveness<\/li><li>Assist in developing and improving internal business development processes, templates, and tools<\/li><li>Support internal business development initiatives that improve team efficiency and strengthen REDD Engineering\u2019s market presence<\/li><\/ul>\n<p><\/p>\n<p>Qualifications<\/p>\n<ul><li>5\u201315+ years of experience in business development, sales, or client management<\/li><li>Experience in consulting, industrial or commercial engineering, construction, or related services<\/li><li>Strong understanding of engineering or construction project delivery<\/li><li>Experience preparing proposals, scopes of work, and project budgets<\/li><li>Comfortable meeting clients on-site and developing long-term professional relationships<\/li><li>Strong communication and relationship-building skills<\/li><li>Self-motivated and able to manage opportunities independently<\/li><\/ul>","post_title":"Business Development Representative","post_link":"https:\/\/turnerstaffing.com\/position\/business-development-representative\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"North Salt Lake","%location_state_id%":"UT","%location_state_name%":"Utah","%location_city_state%":"North Salt Lake, UT","%education%":"","%department%":"TSG","%description%":"<p>Business Development<\/p>\n<ul><li>Identify and pursue new clients and project opportunities within target markets<\/li><li>Track and manage leads, opportunities, and client interactions<\/li><li>Attend industry events, networking opportunities, and client meetings to expand REDD Engineering\u2019s presence<\/li><\/ul>\n<p><\/p>\n<p>Relationship Development<\/p>\n<ul><li>Build and maintain relationships with industrial clients and key decision-makers<\/li><li>Regularly visit client facilities and job sites (anticipated travel ~30% depending on company and client needs)<\/li><li>Serve as a primary point of contact for new project opportunities and client inquiries<\/li><\/ul>\n<p><\/p>\n<p>Strategic Planning<\/p>\n<ul><li>Analyze market conditions, client activity, project cycles, and internal staffing levels to determine which clients and prospects to engage and when in collaboration with Business Development team, Business Manager, and Production Manager<\/li><li>Develop targeted outreach strategies aligned with anticipated project timelines, client decision windows, and projected fluctuations in company workload<\/li><li>Collaborate with the Business Development team, Production Manager, and Business Manager to align pursuits with company capacity and strategic priorities<\/li><\/ul>\n<p><\/p>\n<p>Proposal Development<\/p>\n<ul><li>Coordinate the end-to-end process for RFPs, RFQs, and other client solicitations from kickoff through final delivery<\/li><li>Lead the preparation of proposals and qualifications packages<\/li><li>Work with engineering\/design staff to define project scope, approach, and fee estimates<\/li><li>Coordinate with subconsultants and subcontractors to assemble project pricing<\/li><\/ul>\n<p><\/p>\n<p>Project Initiation<\/p>\n<ul><li>Support the transition of awarded projects to internal project teams<\/li><li>Assist with early project planning and client coordination to ensure a smooth kickoff<\/li><\/ul>\n<p><\/p>\n<p>Department Development<\/p>\n<ul><li>Develop and maintain business development resources including presentations and marketing materials<\/li><li>Maintain accurate documentation in the company CRM to support opportunity tracking, client history, and market intelligence<\/li><li>Document client feedback, relationship insights, and market observations to strengthen institutional knowledge and future pursuits<\/li><li>Prepare reports and summaries for company leadership to help assess business development performance, market trends, and strategy effectiveness<\/li><li>Assist in developing and improving internal business development processes, templates, and tools<\/li><li>Support internal business development initiatives that improve team efficiency and strengthen REDD Engineering\u2019s market presence<\/li><\/ul>\n<p><\/p>\n<p>Qualifications<\/p>\n<ul><li>5\u201315+ years of experience in business development, sales, or client management<\/li><li>Experience in consulting, industrial or commercial engineering, construction, or related services<\/li><li>Strong understanding of engineering or construction project delivery<\/li><li>Experience preparing proposals, scopes of work, and project budgets<\/li><li>Comfortable meeting clients on-site and developing long-term professional relationships<\/li><li>Strong communication and relationship-building skills<\/li><li>Self-motivated and able to manage opportunities independently<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/c613ccceebf4-business-development-representative","%breezy_id%":"c613ccceebf4","%breezy_friendly_id%":"c613ccceebf4-business-development-representative","%breezy_created_date%":"2026-03-26T19:27:06.891Z","%breezy_updated_date%":"2026-05-21T15:01:34.537Z","%_wpgmp_location_city%":"North Salt Lake","%_wpgmp_location_state%":"UT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"North Salt Lake, UT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8485564","%_wpgmp_metabox_longitude%":"-111.9068824","%rank_math_internal_links_processed%":"1"}},"id":3704,"infowindow_disable":false},{"source":"post","title":"Rebuild Technician\/Shop Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Rebuild Technician\/Shop Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Rebuild Technician \/ Shop Mechanic Schedule: 10 days on \/ 4 days off (10\u00d74) Position Overview Turner Staffing Group is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/rebuild-technician-shop-mechanic\/\" name=\"Rebuild Technician\/Shop Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Rebuild Technician \/ Shop Mechanic Schedule: 10 days on \/ 4 days off (10\u00d74) Position Overview Turner Staffing Group is&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482948","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0725488","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/rebuild-technician-shop-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Rebuild Technician \/ Shop Mechanic Schedule: 10 days on \/ 4 days off (10\u00d74) Position Overview Turner Staffing Group is&hellip;","post_content":"<h2><strong>Rebuild Technician \/ Shop Mechanic<\/strong><\/h2>\n<p>Schedule: 10 days on \/ 4 days off (10\u00d74)<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>Turner Staffing Group is seeking a Rebuild Technician \/ Shop Mechanic to support high-volume component rebuild and repair operations. This role is ideal for a mechanically strong technician who thrives in a fast-paced shop environment and takes pride in precision rebuild work. The position focuses heavily on component teardown, inspection, rebuild, and testing, with a strong emphasis on reading schematics and working to tight tolerances.<\/p>\n<p>This is a hands-on role supporting fleet and field operations by restoring critical components to service-ready condition.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Rebuild and overhaul mechanical components including:<\/p>\n<ul>\n<li>\n<p>Hydraulic cylinders<\/p>\n<\/li>\n<li>\n<p>Gearboxes and drivetrains<\/p>\n<\/li>\n<li>\n<p>Cylinder heads and related assemblies<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Disassemble, inspect, measure, and reassemble components to specification<\/p>\n<\/li>\n<li>\n<p>Diagnose component failures and determine repair or rebuild requirements<\/p>\n<\/li>\n<li>\n<p>Read and interpret mechanical drawings, schematics, service manuals, and technical documentation<\/p>\n<\/li>\n<li>\n<p>Perform precision work using hand tools, presses, measuring tools, and shop equipment<\/p>\n<\/li>\n<li>\n<p>Identify wear patterns, failure causes, and recommend corrective actions<\/p>\n<\/li>\n<li>\n<p>Test rebuilt components to verify proper function and performance<\/p>\n<\/li>\n<li>\n<p>Maintain accurate rebuild documentation and work orders<\/p>\n<\/li>\n<li>\n<p>Work efficiently in a production-oriented shop with multiple rebuilds in progress<\/p>\n<\/li>\n<li>\n<p>Follow all safety procedures and maintain a clean, organized work area<\/p>\n<\/li>\n<li>\n<p>Collaborate with shop leadership and peers to meet turnaround timelines<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Experience<\/strong><\/h3>\n<ul>\n<li>\n<p>Strong mechanical aptitude with hands-on rebuild experience<\/p>\n<\/li>\n<li>\n<p>Proven experience rebuilding hydraulic cylinders, heads, gearboxes, or similar components<\/p>\n<\/li>\n<li>\n<p>Strong ability to read and work from schematics and technical drawings<\/p>\n<\/li>\n<li>\n<p>Experience working in fast-paced shop or production rebuild environments<\/p>\n<\/li>\n<li>\n<p>Familiarity with tight tolerances, measurements, and quality control standards<\/p>\n<\/li>\n<li>\n<p>Ability to troubleshoot mechanical failures and identify root causes<\/p>\n<\/li>\n<li>\n<p>Experience using precision measuring tools (micrometers, calipers, gauges, etc.)<\/p>\n<\/li>\n<li>\n<p>Welding or fabrication experience is a plus but not required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\n<p>High attention to detail and workmanship quality<\/p>\n<\/li>\n<li>\n<p>Strong time-management skills with the ability to prioritize work<\/p>\n<\/li>\n<li>\n<p>Mechanical problem-solving mindset<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Comfortable working under production deadlines<\/p>\n<\/li>\n<li>\n<p>Commitment to safety and continuous improvement<\/p>\n<\/li>\n<\/ul>\n<h3>Work Schedule<\/h3>\n<ul>\n<li>\n<p>10 days on \/ 4 days off (10\u00d74 rotation)<\/p>\n<\/li>\n<li>\n<p>Shop-based role with consistent workload<\/p>\n<\/li>\n<\/ul>","post_title":"Rebuild Technician\/Shop Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/rebuild-technician-shop-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"","%department%":"TSG","%description%":"<h2><strong>Rebuild Technician \/ Shop Mechanic<\/strong><\/h2>\n<p>Schedule: 10 days on \/ 4 days off (10\u00d74)<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>Turner Staffing Group is seeking a Rebuild Technician \/ Shop Mechanic to support high-volume component rebuild and repair operations. This role is ideal for a mechanically strong technician who thrives in a fast-paced shop environment and takes pride in precision rebuild work. The position focuses heavily on component teardown, inspection, rebuild, and testing, with a strong emphasis on reading schematics and working to tight tolerances.<\/p>\n<p>This is a hands-on role supporting fleet and field operations by restoring critical components to service-ready condition.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Rebuild and overhaul mechanical components including:<\/p>\n<ul>\n<li>\n<p>Hydraulic cylinders<\/p>\n<\/li>\n<li>\n<p>Gearboxes and drivetrains<\/p>\n<\/li>\n<li>\n<p>Cylinder heads and related assemblies<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Disassemble, inspect, measure, and reassemble components to specification<\/p>\n<\/li>\n<li>\n<p>Diagnose component failures and determine repair or rebuild requirements<\/p>\n<\/li>\n<li>\n<p>Read and interpret mechanical drawings, schematics, service manuals, and technical documentation<\/p>\n<\/li>\n<li>\n<p>Perform precision work using hand tools, presses, measuring tools, and shop equipment<\/p>\n<\/li>\n<li>\n<p>Identify wear patterns, failure causes, and recommend corrective actions<\/p>\n<\/li>\n<li>\n<p>Test rebuilt components to verify proper function and performance<\/p>\n<\/li>\n<li>\n<p>Maintain accurate rebuild documentation and work orders<\/p>\n<\/li>\n<li>\n<p>Work efficiently in a production-oriented shop with multiple rebuilds in progress<\/p>\n<\/li>\n<li>\n<p>Follow all safety procedures and maintain a clean, organized work area<\/p>\n<\/li>\n<li>\n<p>Collaborate with shop leadership and peers to meet turnaround timelines<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Experience<\/strong><\/h3>\n<ul>\n<li>\n<p>Strong mechanical aptitude with hands-on rebuild experience<\/p>\n<\/li>\n<li>\n<p>Proven experience rebuilding hydraulic cylinders, heads, gearboxes, or similar components<\/p>\n<\/li>\n<li>\n<p>Strong ability to read and work from schematics and technical drawings<\/p>\n<\/li>\n<li>\n<p>Experience working in fast-paced shop or production rebuild environments<\/p>\n<\/li>\n<li>\n<p>Familiarity with tight tolerances, measurements, and quality control standards<\/p>\n<\/li>\n<li>\n<p>Ability to troubleshoot mechanical failures and identify root causes<\/p>\n<\/li>\n<li>\n<p>Experience using precision measuring tools (micrometers, calipers, gauges, etc.)<\/p>\n<\/li>\n<li>\n<p>Welding or fabrication experience is a plus but not required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\n<p>High attention to detail and workmanship quality<\/p>\n<\/li>\n<li>\n<p>Strong time-management skills with the ability to prioritize work<\/p>\n<\/li>\n<li>\n<p>Mechanical problem-solving mindset<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Comfortable working under production deadlines<\/p>\n<\/li>\n<li>\n<p>Commitment to safety and continuous improvement<\/p>\n<\/li>\n<\/ul>\n<h3>Work Schedule<\/h3>\n<ul>\n<li>\n<p>10 days on \/ 4 days off (10\u00d74 rotation)<\/p>\n<\/li>\n<li>\n<p>Shop-based role with consistent workload<\/p>\n<\/li>\n<\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/240a87ab194b-rebuild-technician-shop-mechanic","%breezy_id%":"240a87ab194b","%breezy_friendly_id%":"240a87ab194b-rebuild-technician-shop-mechanic","%breezy_created_date%":"2026-02-25T18:34:40.307Z","%breezy_updated_date%":"2026-05-21T15:07:45.742Z","%_wpgmp_location_city%":"Phoenix","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Phoenix, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4482948","%_wpgmp_metabox_longitude%":"-112.0725488","%rank_math_internal_links_processed%":"1"}},"id":3702,"infowindow_disable":false},{"source":"post","title":"Field Service Mechanic &#8211; Heavy Equipment","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Mechanic &#8211; Heavy Equipment\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview The Field Mechanic is responsible for diagnosing, troubleshooting, repairing, and maintaining a wide range of mobile and support&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-mechanic-heavy-equipment\/\" name=\"Field Service Mechanic &#8211; Heavy Equipment\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview The Field Mechanic is responsible for diagnosing, troubleshooting, repairing, and maintaining a wide range of mobile and support&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic-heavy-equipment\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview The Field Mechanic is responsible for diagnosing, troubleshooting, repairing, and maintaining a wide range of mobile and support&hellip;","post_content":"<p><strong>Position Overview<\/strong><\/p>\n<ul><li>The Field Mechanic is responsible for diagnosing, troubleshooting, repairing, and maintaining a wide range of mobile and support equipment in active field environments. This role places a strong emphasis on hydraulic systems, electrical diagnostics, and powertrain troubleshooting, supporting uptime across fleet and jobsite equipment.<\/li><li>Regular travel is required, including work at remote locations.<\/li><li>Typical schedules include 10\u00d74, 9\u00d75, or 8\u00d76, with alternative schedules considered based on operational needs.<\/li><\/ul>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Demonstrate a strong commitment to safety policies, procedures, and jobsite best practices<\/li><li>Diagnose and repair hydraulic, electrical, and mechanical systems on mobile and support equipment<\/li><li>Troubleshoot electrical faults including wiring, sensors, switches, charging systems, starters, and control circuits<\/li><li>Utilize diagnostic tools, software, and test equipment to identify failures and determine corrective action<\/li><li>Repair or replace damaged, worn, or failed components in field conditions<\/li><li>Perform inspections, routine servicing, and documentation of completed work<\/li><li>Dismantle, repair, and reassemble components using hand tools, hoists, and service equipment<\/li><li>Read and interpret service manuals, schematics, wiring diagrams, and technical documentation<\/li><li>Perform welding and light fabrication as needed to complete repairs or modifications<\/li><li>Maintain accurate service records and communicate equipment status to operations and leadership<\/li><li>Exhibit a strong work ethic, adaptability, and a willingness to learn new systems and equipment<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Hands-on experience with drilling rig systems, high-pressure hydraulics, and mobile haul equipment preferred<\/li><li>Familiarity with rig power, hydraulic circuits, and electrically controlled mobile equipment is a plus<\/li><li>Experience troubleshooting large-frame mobile equipment used in drilling or material movement preferred<\/li><li>Experience working on OTR trucks, engines, and auxiliary equipment<\/li><li>Strong mechanical aptitude with the ability to troubleshoot complex failures independently<\/li><li>Valid driver\u2019s license with acceptable driving record<\/li><li>Ability and willingness to travel, work outdoors, and perform duties in all weather conditions<\/li><li>Ability to work effectively under time constraints and shifting priorities<\/li><li>Strong problem-solving skills with the ability to evaluate information and determine effective solutions<\/li><li>Ability to maintain a professional, team-oriented attitude in demanding conditions<\/li><\/ul>\n<p><\/p>\n<p>Industry-leading pay &amp; benefits, including up to 6% 401(k) match<\/p>\n<p>Multiple schedule options available (local or fly-in\/fly-out for the right candidate)<\/p>\n<p>Full per diem and travel pay<\/p>\n<p>Advanced training and career growth opportunities<\/p>\n<p>Monthly tool allowance<\/p>\n<p><br><\/p>","post_title":"Field Service Mechanic &#8211; Heavy Equipment","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic-heavy-equipment\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"TSG","%description%":"<p><strong>Position Overview<\/strong><\/p>\n<ul><li>The Field Mechanic is responsible for diagnosing, troubleshooting, repairing, and maintaining a wide range of mobile and support equipment in active field environments. This role places a strong emphasis on hydraulic systems, electrical diagnostics, and powertrain troubleshooting, supporting uptime across fleet and jobsite equipment.<\/li><li>Regular travel is required, including work at remote locations.<\/li><li>Typical schedules include 10\u00d74, 9\u00d75, or 8\u00d76, with alternative schedules considered based on operational needs.<\/li><\/ul>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Demonstrate a strong commitment to safety policies, procedures, and jobsite best practices<\/li><li>Diagnose and repair hydraulic, electrical, and mechanical systems on mobile and support equipment<\/li><li>Troubleshoot electrical faults including wiring, sensors, switches, charging systems, starters, and control circuits<\/li><li>Utilize diagnostic tools, software, and test equipment to identify failures and determine corrective action<\/li><li>Repair or replace damaged, worn, or failed components in field conditions<\/li><li>Perform inspections, routine servicing, and documentation of completed work<\/li><li>Dismantle, repair, and reassemble components using hand tools, hoists, and service equipment<\/li><li>Read and interpret service manuals, schematics, wiring diagrams, and technical documentation<\/li><li>Perform welding and light fabrication as needed to complete repairs or modifications<\/li><li>Maintain accurate service records and communicate equipment status to operations and leadership<\/li><li>Exhibit a strong work ethic, adaptability, and a willingness to learn new systems and equipment<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Hands-on experience with drilling rig systems, high-pressure hydraulics, and mobile haul equipment preferred<\/li><li>Familiarity with rig power, hydraulic circuits, and electrically controlled mobile equipment is a plus<\/li><li>Experience troubleshooting large-frame mobile equipment used in drilling or material movement preferred<\/li><li>Experience working on OTR trucks, engines, and auxiliary equipment<\/li><li>Strong mechanical aptitude with the ability to troubleshoot complex failures independently<\/li><li>Valid driver\u2019s license with acceptable driving record<\/li><li>Ability and willingness to travel, work outdoors, and perform duties in all weather conditions<\/li><li>Ability to work effectively under time constraints and shifting priorities<\/li><li>Strong problem-solving skills with the ability to evaluate information and determine effective solutions<\/li><li>Ability to maintain a professional, team-oriented attitude in demanding conditions<\/li><\/ul>\n<p><\/p>\n<p>Industry-leading pay &amp; benefits, including up to 6% 401(k) match<\/p>\n<p>Multiple schedule options available (local or fly-in\/fly-out for the right candidate)<\/p>\n<p>Full per diem and travel pay<\/p>\n<p>Advanced training and career growth opportunities<\/p>\n<p>Monthly tool allowance<\/p>\n<p><br><\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/aa2b9fe277c1-field-service-mechanic-heavy-equipment","%breezy_id%":"aa2b9fe277c1","%breezy_friendly_id%":"aa2b9fe277c1-field-service-mechanic-heavy-equipment","%breezy_created_date%":"2026-02-25T18:24:46.791Z","%breezy_updated_date%":"2026-05-21T15:04:44.008Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":3701,"infowindow_disable":false},{"source":"post","title":"Working Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Working Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Working Foreman Position Overview We are seeking a Working Foreman who leads from the front. This role requires a hands-on&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/working-foreman\/\" name=\"Working Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Working Foreman Position Overview We are seeking a Working Foreman who leads from the front. This role requires a hands-on&hellip;","address":"Corvallis, MT, USA","location":{"lat":"46.3140884","city":"Corvallis","state":"MT","country":"United States","lng":"-114.1128734","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/working-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Working Foreman Position Overview We are seeking a Working Foreman who leads from the front. This role requires a hands-on&hellip;","post_content":"<h2>Working Foreman<\/h2>\n<p>Position Overview<\/p>\n<p>We are seeking a Working Foreman who leads from the front. This role requires a hands-on field leader with strong heavy equipment operation experience and the ability to manage crews, daily production, and jobsite execution. The Working Foreman must be versatile and comfortable working across utilities, demolition, site work, and residential projects.<\/p>\n<p>This is an active field position\u2014expect to operate equipment daily while coordinating people, production, and safety.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Operate heavy equipment including excavators, dozers, loaders, skid steers, and related machinery<\/p>\n<\/li>\n<li>\n<p>Lead and direct field crews to safely and efficiently complete daily work activities<\/p>\n<\/li>\n<li>\n<p>Act as the primary on-site lead for assigned projects<\/p>\n<\/li>\n<li>\n<p>Read and interpret plans, grades, and site layouts<\/p>\n<\/li>\n<li>\n<p>Utilize Topcon GPS systems for machine control, layout, and grade accuracy (strongly preferred)<\/p>\n<\/li>\n<li>\n<p>Coordinate daily tasks, equipment, materials, and manpower<\/p>\n<\/li>\n<li>\n<p>Enforce jobsite safety policies and maintain compliance with all safety requirements<\/p>\n<\/li>\n<li>\n<p>Communicate progress, challenges, and resource needs to management<\/p>\n<\/li>\n<li>\n<p>Adapt to varying project scopes and changing field conditions<\/p>\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\n<p>Prior experience as a Working Foreman, Lead Operator, or Senior Equipment Operator<\/p>\n<\/li>\n<li>\n<p>Strong background in heavy equipment operation<\/p>\n<\/li>\n<li>\n<p>Experience supervising and leading crews in the field<\/p>\n<\/li>\n<li>\n<p>Topcon GPS experience is a significant plus<\/p>\n<\/li>\n<li>\n<p>Versatility across utilities, demolition, site work, and residential construction<\/p>\n<\/li>\n<li>\n<p>Solid understanding of jobsite safety and best practices<\/p>\n<\/li>\n<li>\n<p>Strong work ethic, accountability, and reliability<\/p>\n<\/li>\n<li>\n<p>Willingness to travel when required<\/p>\n<\/li>\n<li>\n<p>Understanding that Montana weather may result in periodic no-work days<\/p>\n<\/li>\n<\/ul>\n<h3>What Success Looks Like<\/h3>\n<ul>\n<li>\n<p>Crews are organized, productive, and working safely<\/p>\n<\/li>\n<li>\n<p>Equipment is operated efficiently and maintained responsibly<\/p>\n<\/li>\n<li>\n<p>Projects stay on track despite changing conditions<\/p>\n<\/li>\n<li>\n<p>Clear communication between field leadership and management<\/p>\n<\/li>\n<li>\n<p>High-quality workmanship delivered consistently<\/p>\n<\/li>\n<\/ul>\n<h3>Why This Role<\/h3>\n<p>This position offers steady, hands-on work with a contractor that values leadership, versatility, and practical field experience. It is an ideal opportunity for someone who wants responsibility, variety in project types, and the ability to lead crews while remaining active in the field.<\/p>","post_title":"Working Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/working-foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Corvallis","%location_state_id%":"MT","%location_state_name%":"Montana","%location_city_state%":"Corvallis, MT","%education%":"","%department%":"TSG","%description%":"<h2>Working Foreman<\/h2>\n<p>Position Overview<\/p>\n<p>We are seeking a Working Foreman who leads from the front. This role requires a hands-on field leader with strong heavy equipment operation experience and the ability to manage crews, daily production, and jobsite execution. The Working Foreman must be versatile and comfortable working across utilities, demolition, site work, and residential projects.<\/p>\n<p>This is an active field position\u2014expect to operate equipment daily while coordinating people, production, and safety.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Operate heavy equipment including excavators, dozers, loaders, skid steers, and related machinery<\/p>\n<\/li>\n<li>\n<p>Lead and direct field crews to safely and efficiently complete daily work activities<\/p>\n<\/li>\n<li>\n<p>Act as the primary on-site lead for assigned projects<\/p>\n<\/li>\n<li>\n<p>Read and interpret plans, grades, and site layouts<\/p>\n<\/li>\n<li>\n<p>Utilize Topcon GPS systems for machine control, layout, and grade accuracy (strongly preferred)<\/p>\n<\/li>\n<li>\n<p>Coordinate daily tasks, equipment, materials, and manpower<\/p>\n<\/li>\n<li>\n<p>Enforce jobsite safety policies and maintain compliance with all safety requirements<\/p>\n<\/li>\n<li>\n<p>Communicate progress, challenges, and resource needs to management<\/p>\n<\/li>\n<li>\n<p>Adapt to varying project scopes and changing field conditions<\/p>\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\n<p>Prior experience as a Working Foreman, Lead Operator, or Senior Equipment Operator<\/p>\n<\/li>\n<li>\n<p>Strong background in heavy equipment operation<\/p>\n<\/li>\n<li>\n<p>Experience supervising and leading crews in the field<\/p>\n<\/li>\n<li>\n<p>Topcon GPS experience is a significant plus<\/p>\n<\/li>\n<li>\n<p>Versatility across utilities, demolition, site work, and residential construction<\/p>\n<\/li>\n<li>\n<p>Solid understanding of jobsite safety and best practices<\/p>\n<\/li>\n<li>\n<p>Strong work ethic, accountability, and reliability<\/p>\n<\/li>\n<li>\n<p>Willingness to travel when required<\/p>\n<\/li>\n<li>\n<p>Understanding that Montana weather may result in periodic no-work days<\/p>\n<\/li>\n<\/ul>\n<h3>What Success Looks Like<\/h3>\n<ul>\n<li>\n<p>Crews are organized, productive, and working safely<\/p>\n<\/li>\n<li>\n<p>Equipment is operated efficiently and maintained responsibly<\/p>\n<\/li>\n<li>\n<p>Projects stay on track despite changing conditions<\/p>\n<\/li>\n<li>\n<p>Clear communication between field leadership and management<\/p>\n<\/li>\n<li>\n<p>High-quality workmanship delivered consistently<\/p>\n<\/li>\n<\/ul>\n<h3>Why This Role<\/h3>\n<p>This position offers steady, hands-on work with a contractor that values leadership, versatility, and practical field experience. It is an ideal opportunity for someone who wants responsibility, variety in project types, and the ability to lead crews while remaining active in the field.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/4b3d2a996a6d-working-foreman","%breezy_id%":"4b3d2a996a6d","%breezy_friendly_id%":"4b3d2a996a6d-working-foreman","%breezy_created_date%":"2026-02-23T14:23:57.140Z","%breezy_updated_date%":"2026-05-21T15:08:58.071Z","%_wpgmp_location_city%":"Corvallis","%_wpgmp_location_state%":"MT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Corvallis, MT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"46.3140884","%_wpgmp_metabox_longitude%":"-114.1128734","%rank_math_internal_links_processed%":"1"}},"id":3700,"infowindow_disable":false},{"source":"post","title":"AC\/DC Winder II","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    AC\/DC Winder II\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Primary Purpose: Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/ac-dc-winder-ii\/\" name=\"AC\/DC Winder II\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Primary Purpose: Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding&hellip;","address":"Casper, WY, USA","location":{"lat":"42.848709","city":"Casper","state":"WY","country":"United States","lng":"-106.2980824","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/ac-dc-winder-ii\/","zoom":19,"extra_fields":{"post_excerpt":"Primary Purpose: Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding&hellip;","post_content":"<p>Primary Purpose:  Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding failure damage, recording data from the original winding, making new coils, winding, and performing voltage testing on windings. <\/p>\n<p>Essential Functions: <\/p>\n<p>\u2022\tWinding \u2013 Performs under limited supervision. <\/p>\n<p>o \tRewind various kinds of electromechanical equipment, including but not limited to single-phase stators, threephase stators, three phase rotors, fields, and coils. Operate proper insulating techniques and\/or requirements during rewinding. <\/p>\n<p>o\tDismantle and\/or strip damaged or unserviceable electromechanical equipment, including media blasting. <\/p>\n<p>o\tInspect various kinds of electromechanical equipment for winding damage and evidence of electrical malfunctions. <\/p>\n<p>o\tDocument\/record all relevant data specific to unit\u2019s electromagnetic characteristics, operating conditions, existing damage, or intended serviceability. <\/p>\n<p>o\tPrepare all reusable parts for rewinding and inspect renewed parts for hidden, structural damage or unusual conditions. <\/p>\n<p>o\tWind various electromechanical equipment. <\/p>\n<p>o \tTest rewound electromechanical equipment according to EASA Standards and document test results. <\/p>\n<p>o \tComplete required paperwork for each job accurately and on a timely basis. <\/p>\n<p>o \tOperate specified repair and testing equipment, including but not limited to  winding machines, test panels, surge testers, Hipot, core-loss testers, cut-off saws, burnout ovens, bake ovens, grinders, cranes, forklift trucks, pallet trucks, brazing units, dip tanks, VPI systems, and various hand held power and non-power tools. <\/p>\n<p>\u2022\tOther o Observe all safety procedures and use proper safety equipment including eye, ear, and hand protection. <\/p>\n<p>o       Maintain a clean, neat, and safe work environment at all times. o Operate and maintain equipment in a safe manner at all times.   <\/p>\n<p>o\tPromote strong company image and maintain positive working relationships at all times including professional behavior with customers and co-workers including coordinators. <\/p>\n<p>o\tProvide outstanding customer service at all times. <\/p>\n<p>o \tPerform work according to established company policies and procedures. <\/p>\n<p>o\tPerform other duties as requested. <\/p>\n<p>Requirements: <\/p>\n<p>\u2022\tEducation:   <\/p>\n<p>o High school diploma or equivalent. <\/p>\n<p>\u2022\tExperience:   <\/p>\n<p>o\tTwo years of winding experience. <\/p>\n<p>\u2022\tOther: <\/p>\n<p>o\tAbility to perform basic math functions including addition, subtraction, multiplication, division including understanding fractions. <\/p>\n<p>o\tAbility to read, write, and comprehend simple to complex written and verbal instructions. o \tAbility to understand, perform, and retain various job related training, operational, and safety procedures. o \tAbility to exercise initiative, judgment, and decision making related to routine duties within set company standards.  <\/p>\n<p>o\tAbility to operate machinery and hoists. <\/p>\n<p>o\tKnowledge of small machine shop machines required. <\/p>\n<p>o\tVery infrequent travel may be required.<\/p>","post_title":"AC\/DC Winder II","post_link":"https:\/\/turnerstaffing.com\/position\/ac-dc-winder-ii\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Casper","%location_state_id%":"WY","%location_state_name%":"Wyoming","%location_city_state%":"Casper, WY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p>Primary Purpose:  Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding failure damage, recording data from the original winding, making new coils, winding, and performing voltage testing on windings. <\/p>\n<p>Essential Functions: <\/p>\n<p>\u2022\tWinding \u2013 Performs under limited supervision. <\/p>\n<p>o \tRewind various kinds of electromechanical equipment, including but not limited to single-phase stators, threephase stators, three phase rotors, fields, and coils. Operate proper insulating techniques and\/or requirements during rewinding. <\/p>\n<p>o\tDismantle and\/or strip damaged or unserviceable electromechanical equipment, including media blasting. <\/p>\n<p>o\tInspect various kinds of electromechanical equipment for winding damage and evidence of electrical malfunctions. <\/p>\n<p>o\tDocument\/record all relevant data specific to unit\u2019s electromagnetic characteristics, operating conditions, existing damage, or intended serviceability. <\/p>\n<p>o\tPrepare all reusable parts for rewinding and inspect renewed parts for hidden, structural damage or unusual conditions. <\/p>\n<p>o\tWind various electromechanical equipment. <\/p>\n<p>o \tTest rewound electromechanical equipment according to EASA Standards and document test results. <\/p>\n<p>o \tComplete required paperwork for each job accurately and on a timely basis. <\/p>\n<p>o \tOperate specified repair and testing equipment, including but not limited to  winding machines, test panels, surge testers, Hipot, core-loss testers, cut-off saws, burnout ovens, bake ovens, grinders, cranes, forklift trucks, pallet trucks, brazing units, dip tanks, VPI systems, and various hand held power and non-power tools. <\/p>\n<p>\u2022\tOther o Observe all safety procedures and use proper safety equipment including eye, ear, and hand protection. <\/p>\n<p>o       Maintain a clean, neat, and safe work environment at all times. o Operate and maintain equipment in a safe manner at all times.   <\/p>\n<p>o\tPromote strong company image and maintain positive working relationships at all times including professional behavior with customers and co-workers including coordinators. <\/p>\n<p>o\tProvide outstanding customer service at all times. <\/p>\n<p>o \tPerform work according to established company policies and procedures. <\/p>\n<p>o\tPerform other duties as requested. <\/p>\n<p>Requirements: <\/p>\n<p>\u2022\tEducation:   <\/p>\n<p>o High school diploma or equivalent. <\/p>\n<p>\u2022\tExperience:   <\/p>\n<p>o\tTwo years of winding experience. <\/p>\n<p>\u2022\tOther: <\/p>\n<p>o\tAbility to perform basic math functions including addition, subtraction, multiplication, division including understanding fractions. <\/p>\n<p>o\tAbility to read, write, and comprehend simple to complex written and verbal instructions. o \tAbility to understand, perform, and retain various job related training, operational, and safety procedures. o \tAbility to exercise initiative, judgment, and decision making related to routine duties within set company standards.  <\/p>\n<p>o\tAbility to operate machinery and hoists. <\/p>\n<p>o\tKnowledge of small machine shop machines required. <\/p>\n<p>o\tVery infrequent travel may be required.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/9a748c54ec1d-ac-dc-winder-ii","%breezy_id%":"9a748c54ec1d","%breezy_friendly_id%":"9a748c54ec1d-ac-dc-winder-ii","%breezy_created_date%":"2025-12-09T20:27:30.912Z","%breezy_updated_date%":"2026-05-21T15:00:13.828Z","%_wpgmp_location_city%":"Casper","%_wpgmp_location_state%":"WY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Casper, WY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.848709","%_wpgmp_metabox_longitude%":"-106.2980824","%rank_math_internal_links_processed%":"1"}},"id":3699,"infowindow_disable":false},{"source":"post","title":"777 Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    777 Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a highly skilled and experienced Haul Truck Driver&nbsp;to operate a 777 at a mining site&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/777-haul-truck-driver\/\" name=\"777 Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a highly skilled and experienced Haul Truck Driver&nbsp;to operate a 777 at a mining site&hellip;","address":"Bullhead City, AZ, USA","location":{"lat":"35.1359386","city":"Bullhead City","state":"AZ","country":"United States","lng":"-114.5285981","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/777-haul-truck-driver\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a highly skilled and experienced Haul Truck Driver&nbsp;to operate a 777 at a mining site&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Haul Truck Driver<\/strong>&nbsp;to operate a <strong>777<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have&nbsp;<strong>5<\/strong><strong>&nbsp;years of heavy equipment operation experience<\/strong>, with specific expertise in haul trucks in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a 777 haul truck in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p><\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>2-3<\/strong><strong>&nbsp;years of experience<\/strong> operating haul trucks (preferably 777 or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","post_title":"777 Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/777-haul-truck-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bullhead City","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bullhead City, AZ","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Haul Truck Driver<\/strong>&nbsp;to operate a <strong>777<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have&nbsp;<strong>5<\/strong><strong>&nbsp;years of heavy equipment operation experience<\/strong>, with specific expertise in haul trucks in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a 777 haul truck in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p><\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>2-3<\/strong><strong>&nbsp;years of experience<\/strong> operating haul trucks (preferably 777 or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ec0b5018a4b7-777-haul-truck-driver","%breezy_id%":"ec0b5018a4b7","%breezy_friendly_id%":"ec0b5018a4b7-777-haul-truck-driver","%breezy_created_date%":"2025-05-21T18:49:11.934Z","%breezy_updated_date%":"2026-05-21T18:33:28.860Z","%_wpgmp_location_city%":"Bullhead City","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bullhead City, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1359386","%_wpgmp_metabox_longitude%":"-114.5285981","%rank_math_internal_links_processed%":"1"}},"id":3698,"infowindow_disable":false},{"source":"post","title":"Field Services Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Services Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY: The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-services-technician\/\" name=\"Field Services Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY: The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA&hellip;","address":"Dallas, TX, USA","location":{"lat":"32.7766642","city":"Dallas","state":"TX","country":"United States","lng":"-96.7969879","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-services-technician\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA&hellip;","post_content":"<p><strong><u>POSITION SUMMARY:<\/u><\/strong><\/p>\n<p>The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA region, based out of Dallas\/Fort Worth, TX. The role involves troubleshooting mechanical, electrical, and plumbing system issues, as well as documenting and tracking work hours and project-related costs. The technician will collaborate with skilled trades, contractors, engineers, sales teams, purchasing, accounting, and other resources to ensure excellent service for customer accounts within the assigned territory.<\/p>\n<p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES<\/u><\/strong>:<\/p>\n<p>Formal training in Mechanical, Electrical, Engineering disciplines, or related construction trades. Bachelor's degree is preferred.<\/p>\n<p>5-7 years of prior experience in preventative\/predictive maintenance with industrial mechanical or fluid handling\/pumping systems. A basic understanding of fabrication, metals, welding, project estimation, electrical controls, and mechanical systems in an industrial environment is essential. Strong foundational troubleshooting and technical problem-solving skills are required.<\/p>\n<p>Advanced computer skills, ability to work with web-based systems.<\/p>\n<p>Ability to work independently to achieve assigned tasks<\/p>\n<p>Excellent customer service, time management and personal organizational skills are essential.<\/p>\n<p>Attention to detail, mathematical proficiency and ability to document and track service accounts effectively and thoroughly. <\/p>\n<p>Will be required to be on-call 24\/7 on a rotating basis<\/p>\n<p>Must have reliable transportation and clean driving record<\/p>\n<p>Required Travel up to 25%.<\/p>\n<p><strong><u>WORK ENVIRONMENT \/ CONDITIONS \/ PHYSICAL DEMANDS<\/u><\/strong><strong>:<\/strong><\/p>\n<p>These are considered essential duties and represent the core tasks of the job. The work will primarily be performed outdoors. Employees may be required to complete additional related duties as assigned by management. Reasonable accommodations can be provided to assist individuals with disabilities in performing the essential functions. The work environment will include various manufacturing settings as well as outdoor locations. The role may involve prolonged standing, climbing, pulling, and lifting heavy objects.<\/p>","post_title":"Field Services Technician","post_link":"https:\/\/turnerstaffing.com\/position\/field-services-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Dallas","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Dallas, TX","%education%":"","%department%":"TSG","%description%":"<p><strong><u>POSITION SUMMARY:<\/u><\/strong><\/p>\n<p>The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA region, based out of Dallas\/Fort Worth, TX. The role involves troubleshooting mechanical, electrical, and plumbing system issues, as well as documenting and tracking work hours and project-related costs. The technician will collaborate with skilled trades, contractors, engineers, sales teams, purchasing, accounting, and other resources to ensure excellent service for customer accounts within the assigned territory.<\/p>\n<p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES<\/u><\/strong>:<\/p>\n<p>Formal training in Mechanical, Electrical, Engineering disciplines, or related construction trades. Bachelor's degree is preferred.<\/p>\n<p>5-7 years of prior experience in preventative\/predictive maintenance with industrial mechanical or fluid handling\/pumping systems. A basic understanding of fabrication, metals, welding, project estimation, electrical controls, and mechanical systems in an industrial environment is essential. Strong foundational troubleshooting and technical problem-solving skills are required.<\/p>\n<p>Advanced computer skills, ability to work with web-based systems.<\/p>\n<p>Ability to work independently to achieve assigned tasks<\/p>\n<p>Excellent customer service, time management and personal organizational skills are essential.<\/p>\n<p>Attention to detail, mathematical proficiency and ability to document and track service accounts effectively and thoroughly. <\/p>\n<p>Will be required to be on-call 24\/7 on a rotating basis<\/p>\n<p>Must have reliable transportation and clean driving record<\/p>\n<p>Required Travel up to 25%.<\/p>\n<p><strong><u>WORK ENVIRONMENT \/ CONDITIONS \/ PHYSICAL DEMANDS<\/u><\/strong><strong>:<\/strong><\/p>\n<p>These are considered essential duties and represent the core tasks of the job. The work will primarily be performed outdoors. Employees may be required to complete additional related duties as assigned by management. Reasonable accommodations can be provided to assist individuals with disabilities in performing the essential functions. The work environment will include various manufacturing settings as well as outdoor locations. The role may involve prolonged standing, climbing, pulling, and lifting heavy objects.<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/f89975018242-field-services-technician","%breezy_id%":"f89975018242","%breezy_friendly_id%":"f89975018242-field-services-technician","%breezy_created_date%":"2025-03-11T21:05:26.723Z","%breezy_updated_date%":"2026-05-21T19:51:28.588Z","%_wpgmp_location_city%":"Dallas","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dallas, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7766642","%_wpgmp_metabox_longitude%":"-96.7969879","%rank_math_internal_links_processed%":"1"}},"id":3697,"infowindow_disable":false},{"source":"post","title":"Underground Drill Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Underground Drill Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/underground-drill-mechanic\/\" name=\"Underground Drill Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/underground-drill-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","post_content":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.<\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.<\/li><\/ul>\n<p>Essential Functions<\/p>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.<\/li><li>Must have a valid driver's license.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining underground drill&nbsp;equipment (U6 and U8).<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","post_title":"Underground Drill Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/underground-drill-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.<\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.<\/li><\/ul>\n<p>Essential Functions<\/p>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.<\/li><li>Must have a valid driver's license.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining underground drill&nbsp;equipment (U6 and U8).<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3dbe32260365-underground-drill-mechanic","%breezy_id%":"3dbe32260365","%breezy_friendly_id%":"3dbe32260365-underground-drill-mechanic","%breezy_created_date%":"2025-01-14T18:20:04.554Z","%breezy_updated_date%":"2026-05-21T15:08:27.359Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":3696,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Heavy Equipment Mechanic&nbsp; Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-2\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Mechanic&nbsp; Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-2\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Mechanic&nbsp; Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","post_content":"<p style=\"color:#000000\"><strong><u>Heavy Equipment Mechanic&nbsp;<\/u><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Staffing&nbsp;Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing&nbsp;Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<br><\/span><\/strong><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Recondition and replace parts of the heavy equipment<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Operate and test equipment<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Produce detailed service reports and repair logs<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow all established procedures and protocols<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"TSG","%description%":"<p style=\"color:#000000;\"><strong><u>Heavy Equipment Mechanic&nbsp;<\/u><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Staffing&nbsp;Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing&nbsp;Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<br><\/span><\/strong><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Recondition and replace parts of the heavy equipment<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Operate and test equipment<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Produce detailed service reports and repair logs<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow all established procedures and protocols<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/812c4428ce1b-heavy-equipment-mechanic","%breezy_id%":"812c4428ce1b","%breezy_friendly_id%":"812c4428ce1b-heavy-equipment-mechanic","%breezy_created_date%":"2023-03-09T17:38:02.991Z","%breezy_updated_date%":"2026-05-21T15:06:51.424Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":3695,"infowindow_disable":false},{"source":"post","title":"Field Service Technician- Crushing\/Screening Equipment","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician- Crushing\/Screening Equipment\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the Knoxville,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-crushing-screening-equipment-2\/\" name=\"Field Service Technician- Crushing\/Screening Equipment\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the Knoxville,&hellip;","address":"Knoxville, TN, USA","location":{"lat":"35.965266","city":"Knoxville","state":"TN","country":"United States","lng":"-83.923304","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-crushing-screening-equipment-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the Knoxville,&hellip;","post_content":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the Knoxville, TN&nbsp;area. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","post_title":"Field Service Technician- Crushing\/Screening Equipment","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-crushing-screening-equipment-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Knoxville","%location_state_id%":"TN","%location_state_name%":"Tennessee","%location_city_state%":"Knoxville, TN","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the Knoxville, TN&nbsp;area. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/868358b5f049-field-service-technician-crushing-screening-equipment","%breezy_id%":"868358b5f049","%breezy_friendly_id%":"868358b5f049-field-service-technician-crushing-screening-equipment","%breezy_created_date%":"2026-05-20T18:54:49.517Z","%breezy_updated_date%":"2026-05-20T19:00:31.256Z","%_wpgmp_location_city%":"Knoxville","%_wpgmp_location_state%":"TN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Knoxville, TN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.965266","%_wpgmp_metabox_longitude%":"-83.923304","%rank_math_internal_links_processed%":"1"}},"id":3693,"infowindow_disable":false},{"source":"post","title":"Maintenance\/General Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance\/General Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Looking for general laborers to support our client in Montpelier, VA! Candidates will be shoveling belt spillage and will be&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-general-laborer\/\" name=\"Maintenance\/General Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Looking for general laborers to support our client in Montpelier, VA! Candidates will be shoveling belt spillage and will be&hellip;","address":"Montpelier, VA, USA","location":{"lat":"37.8212538","city":"Montpelier","state":"VA","country":"United States","lng":"-77.6844344","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-general-laborer\/","zoom":19,"extra_fields":{"post_excerpt":"Looking for general laborers to support our client in Montpelier, VA! Candidates will be shoveling belt spillage and will be&hellip;","post_content":"<p>Looking for general laborers to support our client in Montpelier, VA!<\/p><p>Candidates will be shoveling belt spillage and will be learning how to operate mining processing equipment like a wet crushing circuit, dryer, magnetic separator, or analytical equipment.<\/p><p>We are looking for employees who are willing to be cross trained and have mechanical skills!<br><\/p>","post_title":"Maintenance\/General Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-general-laborer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Montpelier","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Montpelier, VA","%education%":"","%department%":"TSG","%description%":"<p>Looking for general laborers to support our client in Montpelier, VA!<\/p><p>Candidates will be shoveling belt spillage and will be learning how to operate mining processing equipment like a wet crushing circuit, dryer, magnetic separator, or analytical equipment.<\/p><p>We are looking for employees who are willing to be cross trained and have mechanical skills!<br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ab6813cba777-maintenance-general-laborer","%breezy_id%":"ab6813cba777","%breezy_friendly_id%":"ab6813cba777-maintenance-general-laborer","%breezy_created_date%":"2026-04-22T20:54:43.943Z","%breezy_updated_date%":"2026-05-20T23:03:07.169Z","%_wpgmp_location_city%":"Montpelier","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Montpelier, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"37.8212538","%_wpgmp_metabox_longitude%":"-77.6844344","%rank_math_internal_links_processed%":"1"}},"id":3692,"infowindow_disable":false},{"source":"post","title":"Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Overview Turner Staffing Group is hiring General Laborers to support a client&#8217;s operations in Hinkley, California. This position plays a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/laborer\/\" name=\"Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Overview Turner Staffing Group is hiring General Laborers to support a client&#8217;s operations in Hinkley, California. This position plays a&hellip;","address":"Hinkley, CA, USA","location":{"lat":"34.9344769","city":"Hinkley","state":"CA","country":"United States","lng":"-117.1993469","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/laborer\/","zoom":19,"extra_fields":{"post_excerpt":"Overview Turner Staffing Group is hiring General Laborers to support a client&#8217;s operations in Hinkley, California. This position plays a&hellip;","post_content":"<p><strong>Overview<\/strong><br>\nTurner Staffing Group is hiring General Laborers to support a client's operations in Hinkley, California. This position plays a critical role in maintaining safe, efficient, and productive site operations by assisting crews with general labor tasks, site cleanup, material handling, and operational support in active outdoor environments.<\/p>\n<p>This is an excellent opportunity for dependable, hardworking individuals with experience in construction, mining, quarry, or other heavy industrial environments who are comfortable working outdoors and committed to workplace safety.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul>\n<li>\nPerform general labor duties including shoveling, cleanup, sweeping, and site housekeeping\n<\/li>\n<li>\nAssist crews with material handling, loading\/unloading, and jobsite preparation\n<\/li>\n<li>\nSupport operators, maintenance personnel, and supervisors with daily operational needs\n<\/li>\n<li>\nWork safely around heavy equipment, machinery, and active work zones\n<\/li>\n<li>\nConduct routine inspections of work areas and report safety hazards or damaged equipment\n<\/li>\n<li>\nMaintain clean, organized, and hazard-free work environments\n<\/li>\n<li>\nFollow all company safety policies, site procedures, and MSHA regulations\n<\/li>\n<li>\nUse hand tools and basic equipment safely and effectively\n<\/li>\n<li>\nPerform physically demanding work in outdoor and varying weather conditions\n<\/li>\n<\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul>\n<li>\nPrevious experience working in construction, mining, quarry, industrial, or outdoor labor environments preferred\n<\/li>\n<li>\nStrong understanding of workplace safety practices and hazard awareness\n<\/li>\n<li>\nAbility to lift, carry, bend, climb, and work on uneven terrain throughout the shift\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain prior to start)\n<\/li>\n<li>\nAbility to work in dusty, hot, cold, and physically demanding conditions\n<\/li>\n<li>\nReliable transportation and dependable attendance required\n<\/li>\n<li>\nAbility to follow directions and work effectively as part of a team\n<\/li>\n<\/ul>\n<p><strong>What We\u2019re Looking For<\/strong><\/p>\n<ul>\n<li>\nHardworking individuals who are comfortable working outdoors in tough environments\n<\/li>\n<li>\nCandidates with construction, mining, or heavy labor experience who understand jobsite safety\n<\/li>\n<li>\nTeam players who can adapt to changing priorities and support multiple crews as needed\n<\/li>\n<li>\nDependable workers who arrive ready to work safely and productively every day\n<\/li>\n<li>\nIndividuals with a strong work ethic, positive attitude, and willingness to learn new skills<\/li><\/ul><p><\/p>","post_title":"Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/laborer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Hinkley","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Hinkley, CA","%education%":"","%department%":"TSG","%description%":"<p><strong>Overview<\/strong><br>\nTurner Staffing Group is hiring General Laborers to support a client's operations in Hinkley, California. This position plays a critical role in maintaining safe, efficient, and productive site operations by assisting crews with general labor tasks, site cleanup, material handling, and operational support in active outdoor environments.<\/p>\n<p>This is an excellent opportunity for dependable, hardworking individuals with experience in construction, mining, quarry, or other heavy industrial environments who are comfortable working outdoors and committed to workplace safety.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul>\n<li>\nPerform general labor duties including shoveling, cleanup, sweeping, and site housekeeping\n<\/li>\n<li>\nAssist crews with material handling, loading\/unloading, and jobsite preparation\n<\/li>\n<li>\nSupport operators, maintenance personnel, and supervisors with daily operational needs\n<\/li>\n<li>\nWork safely around heavy equipment, machinery, and active work zones\n<\/li>\n<li>\nConduct routine inspections of work areas and report safety hazards or damaged equipment\n<\/li>\n<li>\nMaintain clean, organized, and hazard-free work environments\n<\/li>\n<li>\nFollow all company safety policies, site procedures, and MSHA regulations\n<\/li>\n<li>\nUse hand tools and basic equipment safely and effectively\n<\/li>\n<li>\nPerform physically demanding work in outdoor and varying weather conditions\n<\/li>\n<\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul>\n<li>\nPrevious experience working in construction, mining, quarry, industrial, or outdoor labor environments preferred\n<\/li>\n<li>\nStrong understanding of workplace safety practices and hazard awareness\n<\/li>\n<li>\nAbility to lift, carry, bend, climb, and work on uneven terrain throughout the shift\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain prior to start)\n<\/li>\n<li>\nAbility to work in dusty, hot, cold, and physically demanding conditions\n<\/li>\n<li>\nReliable transportation and dependable attendance required\n<\/li>\n<li>\nAbility to follow directions and work effectively as part of a team\n<\/li>\n<\/ul>\n<p><strong>What We\u2019re Looking For<\/strong><\/p>\n<ul>\n<li>\nHardworking individuals who are comfortable working outdoors in tough environments\n<\/li>\n<li>\nCandidates with construction, mining, or heavy labor experience who understand jobsite safety\n<\/li>\n<li>\nTeam players who can adapt to changing priorities and support multiple crews as needed\n<\/li>\n<li>\nDependable workers who arrive ready to work safely and productively every day\n<\/li>\n<li>\nIndividuals with a strong work ethic, positive attitude, and willingness to learn new skills<\/li><\/ul><p><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a0637befd653-laborer","%breezy_id%":"a0637befd653","%breezy_friendly_id%":"a0637befd653-laborer","%breezy_created_date%":"2026-05-20T21:56:32.953Z","%breezy_updated_date%":"2026-05-20T21:57:53.846Z","%_wpgmp_location_city%":"Hinkley","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hinkley, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.9344769","%_wpgmp_metabox_longitude%":"-117.1993469","%rank_math_internal_links_processed%":"1"}},"id":3694,"infowindow_disable":false},{"source":"post","title":"Mining Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Overview Turner Staffing Group is hiring a Mining Foreman to support operations in Hinkley, California. This is a leadership role&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-foreman\/\" name=\"Mining Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Overview Turner Staffing Group is hiring a Mining Foreman to support operations in Hinkley, California. This is a leadership role&hellip;","address":"Hinkley, CA, USA","location":{"lat":"34.9344769","city":"Hinkley","state":"CA","country":"United States","lng":"-117.1993469","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Overview Turner Staffing Group is hiring a Mining Foreman to support operations in Hinkley, California. This is a leadership role&hellip;","post_content":"<h3><strong>Overview<\/strong><\/h3>\n<p>Turner Staffing Group is hiring a Mining Foreman to support operations in Hinkley, California. This is a leadership role responsible for overseeing daily production activities, managing crews, and ensuring work is completed safely, efficiently, and in alignment with production goals.<\/p>\n<p>This position is ideal for a hands-on leader with strong field experience who can drive performance, maintain accountability, and lead from the front in an active mining environment.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSupervise and coordinate daily activities of operators, laborers, and support personnel\n<\/li>\n<li>\nEnsure production targets are met while maintaining safety and quality standards\n<\/li>\n<li>\nMonitor and manage equipment utilization and workforce productivity\n<\/li>\n<li>\nEnforce all site safety policies and MSHA regulations\n<\/li>\n<li>\nConduct daily safety meetings, job briefings, and shift handoffs\n<\/li>\n<li>\nIdentify and resolve operational issues in real time\n<\/li>\n<li>\nCoordinate with maintenance teams to minimize downtime\n<\/li>\n<li>\nTrain, mentor, and develop crew members\n<\/li>\n<li>\nMaintain clear communication with site management and client representatives\n<\/li>\n<li>\nComplete required reports, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nProven experience in a supervisory or foreman role within mining, quarry, or heavy civil operations\n<\/li>\n<li>\nStrong knowledge of heavy equipment operations and production processes\n<\/li>\n<li>\nDemonstrated leadership and team management skills\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification required (or ability to obtain prior to start)\n<\/li>\n<li>\nStrong understanding of workplace safety standards and regulations\n<\/li>\n<li>\nAbility to work in a fast-paced, high-production environment\n<\/li>\n<li>\nReliable, organized, and able to make sound decisions under pressure\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\nLeaders who hold their teams accountable while building respect in the field\n<\/li>\n<li>\nIndividuals who prioritize safety without sacrificing production\n<\/li>\n<li>\nProblem-solvers who can think ahead and adapt quickly to changing conditions\n<\/li>\n<li>\nForemen who lead by example and aren\u2019t afraid to be hands-on when needed<\/li><\/ul>","post_title":"Mining Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/mining-foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Hinkley","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Hinkley, CA","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Overview<\/strong><\/h3>\n<p>Turner Staffing Group is hiring a Mining Foreman to support operations in Hinkley, California. This is a leadership role responsible for overseeing daily production activities, managing crews, and ensuring work is completed safely, efficiently, and in alignment with production goals.<\/p>\n<p>This position is ideal for a hands-on leader with strong field experience who can drive performance, maintain accountability, and lead from the front in an active mining environment.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSupervise and coordinate daily activities of operators, laborers, and support personnel\n<\/li>\n<li>\nEnsure production targets are met while maintaining safety and quality standards\n<\/li>\n<li>\nMonitor and manage equipment utilization and workforce productivity\n<\/li>\n<li>\nEnforce all site safety policies and MSHA regulations\n<\/li>\n<li>\nConduct daily safety meetings, job briefings, and shift handoffs\n<\/li>\n<li>\nIdentify and resolve operational issues in real time\n<\/li>\n<li>\nCoordinate with maintenance teams to minimize downtime\n<\/li>\n<li>\nTrain, mentor, and develop crew members\n<\/li>\n<li>\nMaintain clear communication with site management and client representatives\n<\/li>\n<li>\nComplete required reports, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nProven experience in a supervisory or foreman role within mining, quarry, or heavy civil operations\n<\/li>\n<li>\nStrong knowledge of heavy equipment operations and production processes\n<\/li>\n<li>\nDemonstrated leadership and team management skills\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification required (or ability to obtain prior to start)\n<\/li>\n<li>\nStrong understanding of workplace safety standards and regulations\n<\/li>\n<li>\nAbility to work in a fast-paced, high-production environment\n<\/li>\n<li>\nReliable, organized, and able to make sound decisions under pressure\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\nLeaders who hold their teams accountable while building respect in the field\n<\/li>\n<li>\nIndividuals who prioritize safety without sacrificing production\n<\/li>\n<li>\nProblem-solvers who can think ahead and adapt quickly to changing conditions\n<\/li>\n<li>\nForemen who lead by example and aren\u2019t afraid to be hands-on when needed<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/397985735ef1-mining-foreman","%breezy_id%":"397985735ef1","%breezy_friendly_id%":"397985735ef1-mining-foreman","%breezy_created_date%":"2026-04-03T20:05:34.081Z","%breezy_updated_date%":"2026-05-20T20:09:53.431Z","%_wpgmp_location_city%":"Hinkley","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hinkley, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.9344769","%_wpgmp_metabox_longitude%":"-117.1993469","%rank_math_internal_links_processed%":"1"}},"id":3691,"infowindow_disable":false},{"source":"post","title":"Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Overview Turner Staffing Group is hiring a Production Loader Operator to support a mining operation in Hinkley, California. This is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator\/\" name=\"Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Overview Turner Staffing Group is hiring a Production Loader Operator to support a mining operation in Hinkley, California. This is&hellip;","address":"Hinkley, CA, USA","location":{"lat":"34.9344769","city":"Hinkley","state":"CA","country":"United States","lng":"-117.1993469","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Overview Turner Staffing Group is hiring a Production Loader Operator to support a mining operation in Hinkley, California. This is&hellip;","post_content":"<h3><strong>Overview<\/strong><\/h3>\n<p>Turner Staffing Group is hiring a Production Loader Operator to support a mining operation in Hinkley, California. This is a key production role responsible for efficiently loading haul trucks and supporting material movement across the site.<\/p>\n<p>If you\u2019re an experienced operator who takes pride in productivity, precision, and safety, this is an opportunity to be part of a high-performing operation with room to grow.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nOperate a front-end loader to load haul trucks with overburden, ore, or aggregate material\n<\/li>\n<li>\nMaintain consistent production rates while minimizing spillage and rework\n<\/li>\n<li>\nEnsure proper loading techniques to maximize efficiency and equipment longevity\n<\/li>\n<li>\nConduct pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions\n<\/li>\n<li>\nFollow all site safety policies and MSHA regulations\n<\/li>\n<li>\nCommunicate effectively with haul truck drivers, dispatch, and supervisors\n<\/li>\n<li>\nMaintain clean work areas and assist with general production support as needed\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nProven experience operating a production loader in a mining, quarry, or heavy civil environment\n<\/li>\n<li>\nStrong understanding of loading patterns, material handling, and production goals\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification (preferred; may be required prior to start)\n<\/li>\n<li>\nAbility to work in a physically demanding outdoor environment\n<\/li>\n<li>\nStrong situational awareness and commitment to safety\n<\/li>\n<li>\nReliable transportation and consistent attendance\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\nOperators who can load safely, efficiently, and consistently\n<\/li>\n<li>\nIndividuals who understand production targets and take ownership of performance\n<\/li>\n<li>\nTeam players who communicate clearly and work well in a fast-paced environment<\/li><\/ul>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Hinkley","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Hinkley, CA","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Overview<\/strong><\/h3>\n<p>Turner Staffing Group is hiring a Production Loader Operator to support a mining operation in Hinkley, California. This is a key production role responsible for efficiently loading haul trucks and supporting material movement across the site.<\/p>\n<p>If you\u2019re an experienced operator who takes pride in productivity, precision, and safety, this is an opportunity to be part of a high-performing operation with room to grow.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nOperate a front-end loader to load haul trucks with overburden, ore, or aggregate material\n<\/li>\n<li>\nMaintain consistent production rates while minimizing spillage and rework\n<\/li>\n<li>\nEnsure proper loading techniques to maximize efficiency and equipment longevity\n<\/li>\n<li>\nConduct pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions\n<\/li>\n<li>\nFollow all site safety policies and MSHA regulations\n<\/li>\n<li>\nCommunicate effectively with haul truck drivers, dispatch, and supervisors\n<\/li>\n<li>\nMaintain clean work areas and assist with general production support as needed\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nProven experience operating a production loader in a mining, quarry, or heavy civil environment\n<\/li>\n<li>\nStrong understanding of loading patterns, material handling, and production goals\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification (preferred; may be required prior to start)\n<\/li>\n<li>\nAbility to work in a physically demanding outdoor environment\n<\/li>\n<li>\nStrong situational awareness and commitment to safety\n<\/li>\n<li>\nReliable transportation and consistent attendance\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\nOperators who can load safely, efficiently, and consistently\n<\/li>\n<li>\nIndividuals who understand production targets and take ownership of performance\n<\/li>\n<li>\nTeam players who communicate clearly and work well in a fast-paced environment<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/d758d60a8bac-loader-operator","%breezy_id%":"d758d60a8bac","%breezy_friendly_id%":"d758d60a8bac-loader-operator","%breezy_created_date%":"2026-04-03T20:01:27.595Z","%breezy_updated_date%":"2026-05-20T18:54:03.504Z","%_wpgmp_location_city%":"Hinkley","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hinkley, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.9344769","%_wpgmp_metabox_longitude%":"-117.1993469","%rank_math_internal_links_processed%":"1"}},"id":3689,"infowindow_disable":false},{"source":"post","title":"Water Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Water Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Overview Turner Staffing Group is hiring Water Truck Drivers to support a mining operation in Hinkley, California. This role plays&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/water-truck-driver\/\" name=\"Water Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Overview Turner Staffing Group is hiring Water Truck Drivers to support a mining operation in Hinkley, California. This role plays&hellip;","address":"Hinkley, CA, USA","location":{"lat":"34.9344769","city":"Hinkley","state":"CA","country":"United States","lng":"-117.1993469","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/water-truck-driver\/","zoom":19,"extra_fields":{"post_excerpt":"Overview Turner Staffing Group is hiring Water Truck Drivers to support a mining operation in Hinkley, California. This role plays&hellip;","post_content":"<h3><strong>Overview<\/strong><\/h3>\n<p>Turner Staffing Group is hiring Water Truck Drivers to support a mining operation in Hinkley, California. This role plays a key part in maintaining safe and efficient site conditions by controlling dust and supporting road maintenance across the operation.<\/p>\n<p>If you\u2019re dependable, safety-focused, and experienced operating heavy equipment, this is an opportunity to get your foot in the door with a growing operation.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nOperate a water truck to control dust on haul roads, work areas, and around active equipment\n<\/li>\n<li>\nMaintain proper moisture levels on roadways to ensure safe driving conditions for haul trucks and support equipment\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections\n<\/li>\n<li>\nMonitor water levels and refill as needed throughout the shift\n<\/li>\n<li>\nReport equipment malfunctions, unsafe conditions, or hazards immediately\n<\/li>\n<li>\nFollow all site safety policies and MSHA regulations\n<\/li>\n<li>\nCommunicate effectively with supervisors and other operators\n<\/li>\n<li>\nAssist with general site support duties as needed\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nPrevious experience operating a water truck or similar heavy equipment preferred\n<\/li>\n<li>\nValid driver\u2019s license required (CDL may be required depending on equipment)\n<\/li>\n<li>\nMSHA certification (preferred; may be required prior to start)\n<\/li>\n<li>\nAbility to work outdoors in varying weather and site conditions\n<\/li>\n<li>\nStrong awareness of safety and site traffic patterns\n<\/li>\n<li>\nReliable transportation and strong attendance\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\nOperators who understand the importance of dust control and site safety\n<\/li>\n<li>\nSelf-motivated individuals who can manage routes and priorities throughout the shift\n<\/li>\n<li>\nTeam players who communicate well and stay alert in active work zones<\/li><\/ul>","post_title":"Water Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/water-truck-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Hinkley","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Hinkley, CA","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Overview<\/strong><\/h3>\n<p>Turner Staffing Group is hiring Water Truck Drivers to support a mining operation in Hinkley, California. This role plays a key part in maintaining safe and efficient site conditions by controlling dust and supporting road maintenance across the operation.<\/p>\n<p>If you\u2019re dependable, safety-focused, and experienced operating heavy equipment, this is an opportunity to get your foot in the door with a growing operation.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nOperate a water truck to control dust on haul roads, work areas, and around active equipment\n<\/li>\n<li>\nMaintain proper moisture levels on roadways to ensure safe driving conditions for haul trucks and support equipment\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections\n<\/li>\n<li>\nMonitor water levels and refill as needed throughout the shift\n<\/li>\n<li>\nReport equipment malfunctions, unsafe conditions, or hazards immediately\n<\/li>\n<li>\nFollow all site safety policies and MSHA regulations\n<\/li>\n<li>\nCommunicate effectively with supervisors and other operators\n<\/li>\n<li>\nAssist with general site support duties as needed\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nPrevious experience operating a water truck or similar heavy equipment preferred\n<\/li>\n<li>\nValid driver\u2019s license required (CDL may be required depending on equipment)\n<\/li>\n<li>\nMSHA certification (preferred; may be required prior to start)\n<\/li>\n<li>\nAbility to work outdoors in varying weather and site conditions\n<\/li>\n<li>\nStrong awareness of safety and site traffic patterns\n<\/li>\n<li>\nReliable transportation and strong attendance\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\nOperators who understand the importance of dust control and site safety\n<\/li>\n<li>\nSelf-motivated individuals who can manage routes and priorities throughout the shift\n<\/li>\n<li>\nTeam players who communicate well and stay alert in active work zones<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3e1dd1c29066-water-truck-driver","%breezy_id%":"3e1dd1c29066","%breezy_friendly_id%":"3e1dd1c29066-water-truck-driver","%breezy_created_date%":"2026-04-03T19:59:57.173Z","%breezy_updated_date%":"2026-05-20T20:10:12.053Z","%_wpgmp_location_city%":"Hinkley","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hinkley, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.9344769","%_wpgmp_metabox_longitude%":"-117.1993469","%rank_math_internal_links_processed%":"1"}},"id":3688,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Overview Turner Staffing Group is hiring Haul Truck Drivers to support a mining operation in Hinkley, California. This role is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-4\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Overview Turner Staffing Group is hiring Haul Truck Drivers to support a mining operation in Hinkley, California. This role is&hellip;","address":"Hinkley, CA, USA","location":{"lat":"34.9344769","city":"Hinkley","state":"CA","country":"United States","lng":"-117.1993469","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-4\/","zoom":19,"extra_fields":{"post_excerpt":"Overview Turner Staffing Group is hiring Haul Truck Drivers to support a mining operation in Hinkley, California. This role is&hellip;","post_content":"<h3><strong>Overview<\/strong><\/h3>\n<p>Turner Staffing Group is hiring Haul Truck Drivers to support a mining operation in Hinkley, California. This role is critical to daily production and is a great opportunity for individuals who are safety-focused, dependable, and experienced in operating heavy equipment in a mining or quarry environment.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nOperate off-road haul trucks in a safe and efficient manner\n<\/li>\n<li>\nTransport materials such as overburden, ore, and aggregate throughout the site\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections on equipment\n<\/li>\n<li>\nReport equipment issues, safety concerns, or hazards promptly\n<\/li>\n<li>\nMaintain compliance with all site safety standards and MSHA regulations\n<\/li>\n<li>\nCommunicate effectively with dispatch, supervisors, and other operators\n<\/li>\n<li>\nAssist with general site duties as needed\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nPrevious experience operating haul trucks in a mining, quarry, or heavy civil environment preferred\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification (preferred; may be required prior to start)\n<\/li>\n<li>\nAbility to work in a physically demanding outdoor environment in varying weather conditions\n<\/li>\n<li>\nStrong commitment to safety and following procedures\n<\/li>\n<li>\nReliable transportation and consistent attendance\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\nOperators who take pride in running equipment safely and efficiently\n<\/li>\n<li>\nTeam players who can communicate and adapt in a fast-paced environment\n<\/li>\n<li>\nIndividuals who are dependable and ready to work<\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Hinkley","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Hinkley, CA","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Overview<\/strong><\/h3>\n<p>Turner Staffing Group is hiring Haul Truck Drivers to support a mining operation in Hinkley, California. This role is critical to daily production and is a great opportunity for individuals who are safety-focused, dependable, and experienced in operating heavy equipment in a mining or quarry environment.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nOperate off-road haul trucks in a safe and efficient manner\n<\/li>\n<li>\nTransport materials such as overburden, ore, and aggregate throughout the site\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections on equipment\n<\/li>\n<li>\nReport equipment issues, safety concerns, or hazards promptly\n<\/li>\n<li>\nMaintain compliance with all site safety standards and MSHA regulations\n<\/li>\n<li>\nCommunicate effectively with dispatch, supervisors, and other operators\n<\/li>\n<li>\nAssist with general site duties as needed\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nPrevious experience operating haul trucks in a mining, quarry, or heavy civil environment preferred\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification (preferred; may be required prior to start)\n<\/li>\n<li>\nAbility to work in a physically demanding outdoor environment in varying weather conditions\n<\/li>\n<li>\nStrong commitment to safety and following procedures\n<\/li>\n<li>\nReliable transportation and consistent attendance\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\nOperators who take pride in running equipment safely and efficiently\n<\/li>\n<li>\nTeam players who can communicate and adapt in a fast-paced environment\n<\/li>\n<li>\nIndividuals who are dependable and ready to work<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/4ef5e197a8ec-haul-truck-driver","%breezy_id%":"4ef5e197a8ec","%breezy_friendly_id%":"4ef5e197a8ec-haul-truck-driver","%breezy_created_date%":"2026-04-03T19:58:00.456Z","%breezy_updated_date%":"2026-05-20T18:52:48.280Z","%_wpgmp_location_city%":"Hinkley","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hinkley, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.9344769","%_wpgmp_metabox_longitude%":"-117.1993469","%rank_math_internal_links_processed%":"1"}},"id":3687,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician Apprentice &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician Apprentice &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-apprentice-mining\/\" name=\"Industrial Electrician Apprentice &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-apprentice-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems&hellip;","post_content":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems and equipment used in mining operations. This position is designed for individuals seeking hands-on experience in an industrial mining environment while developing the skills required to advance in the electrical trade.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Assist journeyman electricians with installing, maintaining, and repairing industrial electrical systems and mining equipment<\/p>\n<\/li>\n<li>\n<p>Support troubleshooting efforts on motors, conveyors, crushers, pumps, lighting, and power distribution systems<\/p>\n<\/li>\n<li>\n<p>Perform basic electrical tasks under direct supervision, including conduit installation, wire pulling, terminations, and component replacement<\/p>\n<\/li>\n<li>\n<p>Use electrical meters and hand tools to perform testing and inspections as directed<\/p>\n<\/li>\n<li>\n<p>Follow lockout\/tagout procedures and all MSHA, NEC, and site-specific safety regulations<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area and properly care for tools and equipment<\/p>\n<\/li>\n<li>\n<p>Assist with preventative maintenance activities to reduce equipment downtime<\/p>\n<\/li>\n<li>\n<p>Learn to read and interpret electrical schematics, drawings, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Communicate job progress and equipment issues to supervising electricians<\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, training, and apprenticeship-related coursework as required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Enrollment in an electrical apprenticeship program (or equivalent on-the-job training experience)<\/p>\n<\/li>\n<li>\n<p>Basic understanding of electrical theory and safety practices<\/p>\n<\/li>\n<li>\n<p>Willingness to learn and take direction in a production-focused environment<\/p>\n<\/li>\n<li>\n<p>Ability to work safely in industrial and mining conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Tools &amp; Equipment Requirement<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Apprentices must furnish their own basic electrical hand tools and meters<\/strong>, appropriate for apprentice-level work<\/p>\n<\/li>\n<li>\n<p>Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical &amp; Work Environment<\/strong><\/h3>\n<ul>\n<li>\n<p>Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous industrial, construction, or mining experience<\/p>\n<\/li>\n<li>\n<p>MSHA certification or willingness to obtain<\/p>\n<\/li>\n<li>\n<p>Coursework completed toward an electrical apprenticeship<\/p>\n<\/li>\n<\/ul><p><\/p>","post_title":"Industrial Electrician Apprentice &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-apprentice-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"","%department%":"TSG","%description%":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems and equipment used in mining operations. This position is designed for individuals seeking hands-on experience in an industrial mining environment while developing the skills required to advance in the electrical trade.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Assist journeyman electricians with installing, maintaining, and repairing industrial electrical systems and mining equipment<\/p>\n<\/li>\n<li>\n<p>Support troubleshooting efforts on motors, conveyors, crushers, pumps, lighting, and power distribution systems<\/p>\n<\/li>\n<li>\n<p>Perform basic electrical tasks under direct supervision, including conduit installation, wire pulling, terminations, and component replacement<\/p>\n<\/li>\n<li>\n<p>Use electrical meters and hand tools to perform testing and inspections as directed<\/p>\n<\/li>\n<li>\n<p>Follow lockout\/tagout procedures and all MSHA, NEC, and site-specific safety regulations<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area and properly care for tools and equipment<\/p>\n<\/li>\n<li>\n<p>Assist with preventative maintenance activities to reduce equipment downtime<\/p>\n<\/li>\n<li>\n<p>Learn to read and interpret electrical schematics, drawings, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Communicate job progress and equipment issues to supervising electricians<\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, training, and apprenticeship-related coursework as required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Enrollment in an electrical apprenticeship program (or equivalent on-the-job training experience)<\/p>\n<\/li>\n<li>\n<p>Basic understanding of electrical theory and safety practices<\/p>\n<\/li>\n<li>\n<p>Willingness to learn and take direction in a production-focused environment<\/p>\n<\/li>\n<li>\n<p>Ability to work safely in industrial and mining conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Tools &amp; Equipment Requirement<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Apprentices must furnish their own basic electrical hand tools and meters<\/strong>, appropriate for apprentice-level work<\/p>\n<\/li>\n<li>\n<p>Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical &amp; Work Environment<\/strong><\/h3>\n<ul>\n<li>\n<p>Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous industrial, construction, or mining experience<\/p>\n<\/li>\n<li>\n<p>MSHA certification or willingness to obtain<\/p>\n<\/li>\n<li>\n<p>Coursework completed toward an electrical apprenticeship<\/p>\n<\/li>\n<\/ul><p><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/8e182d79e8b5-industrial-electrician-apprentice-mining","%breezy_id%":"8e182d79e8b5","%breezy_friendly_id%":"8e182d79e8b5-industrial-electrician-apprentice-mining","%breezy_created_date%":"2026-01-29T20:37:43.132Z","%breezy_updated_date%":"2026-05-20T20:12:46.377Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":3686,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-mining\/\" name=\"Industrial Electrician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining&hellip;","post_content":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining operations. This role supports safe, reliable production by ensuring all electrical components operate efficiently and in compliance with applicable safety regulations and standards.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Install, inspect, maintain, and repair industrial electrical systems, including power distribution, motors, MCCs, VFDs, PLCs, lighting systems, and instrumentation<\/p>\n<\/li>\n<li>\n<p>Troubleshoot electrical faults on mining equipment such as conveyors, crushers, pumps, drills, and processing plant equipment<\/p>\n<\/li>\n<li>\n<p>Perform preventative and corrective maintenance to minimize downtime<\/p>\n<\/li>\n<li>\n<p>Read and interpret electrical schematics, blueprints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Test electrical systems using appropriate meters and diagnostic tools<\/p>\n<\/li>\n<li>\n<p>Ensure all work complies with MSHA regulations, NEC standards, and site-specific safety policies<\/p>\n<\/li>\n<li>\n<p>Lockout\/tagout equipment and follow all safety and environmental procedures<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with maintenance, operations, and supervision regarding equipment status and repairs<\/p>\n<\/li>\n<li>\n<p>Maintain accurate maintenance records and documentation<\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, inspections, and audits as required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Journeyman Electrician certification or equivalent industrial electrical experience<\/p>\n<\/li>\n<li>\n<p>Experience as an industrial electrician, preferably in a mining or heavy industrial environment<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of AC\/DC systems, motor controls, and industrial electrical troubleshooting<\/p>\n<\/li>\n<li>\n<p>Ability to work independently in a fast-paced, production-driven environment<\/p>\n<\/li>\n<li>\n<p>Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Tools &amp; Equipment Requirement<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Employees must furnish their own basic electrical hand tools and meters<\/strong>, including but not limited to multimeters, clamp meters, and standard electrician tools<\/p>\n<\/li>\n<li>\n<p>Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical &amp; Work Environment<\/strong><\/h3>\n<ul>\n<li>\n<p>Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification<\/p>\n<\/li>\n<li>\n<p>Experience with PLC troubleshooting and VFDs<\/p>\n<\/li>\n<li>\n<p>Mining or aggregate industry experience<\/p><\/li><\/ul>\n<p><\/p>","post_title":"Industrial Electrician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"","%department%":"TSG","%description%":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining operations. This role supports safe, reliable production by ensuring all electrical components operate efficiently and in compliance with applicable safety regulations and standards.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Install, inspect, maintain, and repair industrial electrical systems, including power distribution, motors, MCCs, VFDs, PLCs, lighting systems, and instrumentation<\/p>\n<\/li>\n<li>\n<p>Troubleshoot electrical faults on mining equipment such as conveyors, crushers, pumps, drills, and processing plant equipment<\/p>\n<\/li>\n<li>\n<p>Perform preventative and corrective maintenance to minimize downtime<\/p>\n<\/li>\n<li>\n<p>Read and interpret electrical schematics, blueprints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Test electrical systems using appropriate meters and diagnostic tools<\/p>\n<\/li>\n<li>\n<p>Ensure all work complies with MSHA regulations, NEC standards, and site-specific safety policies<\/p>\n<\/li>\n<li>\n<p>Lockout\/tagout equipment and follow all safety and environmental procedures<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with maintenance, operations, and supervision regarding equipment status and repairs<\/p>\n<\/li>\n<li>\n<p>Maintain accurate maintenance records and documentation<\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, inspections, and audits as required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Journeyman Electrician certification or equivalent industrial electrical experience<\/p>\n<\/li>\n<li>\n<p>Experience as an industrial electrician, preferably in a mining or heavy industrial environment<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of AC\/DC systems, motor controls, and industrial electrical troubleshooting<\/p>\n<\/li>\n<li>\n<p>Ability to work independently in a fast-paced, production-driven environment<\/p>\n<\/li>\n<li>\n<p>Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Tools &amp; Equipment Requirement<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Employees must furnish their own basic electrical hand tools and meters<\/strong>, including but not limited to multimeters, clamp meters, and standard electrician tools<\/p>\n<\/li>\n<li>\n<p>Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical &amp; Work Environment<\/strong><\/h3>\n<ul>\n<li>\n<p>Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification<\/p>\n<\/li>\n<li>\n<p>Experience with PLC troubleshooting and VFDs<\/p>\n<\/li>\n<li>\n<p>Mining or aggregate industry experience<\/p><\/li><\/ul>\n<p><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/e0ad9dd5b6c6-industrial-electrician-mining","%breezy_id%":"e0ad9dd5b6c6","%breezy_friendly_id%":"e0ad9dd5b6c6-industrial-electrician-mining","%breezy_created_date%":"2026-01-29T20:30:02.554Z","%breezy_updated_date%":"2026-05-20T20:12:21.330Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":3685,"infowindow_disable":false},{"source":"post","title":"Mining Plant Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Plant Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-plant-electrician\/\" name=\"Mining Plant Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems.&hellip;","address":"Montpelier, VA, USA","location":{"lat":"37.8212538","city":"Montpelier","state":"VA","country":"United States","lng":"-77.6844344","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-plant-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems.&hellip;","post_content":"<p>The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems. May mentor junior electricians.<\/p>\n<h2>Responsibilities<\/h2>\n<ul><li>Diagnose and repair high- and low-voltage systems, motor controls, and drives.<\/li><li>Install and maintain PLCs, VFDs, and control circuits.<\/li><li>Lead electrical projects and ensure code compliance.<\/li><li>Mentor Electrician I and II personnel and support cross-training.<\/li><li>Interface with automation, engineering, and maintenance teams.<\/li><li>Maintain technical documentation and update panel schematics.<\/li><li>Additional duties as assigned.<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>High school diploma or general education degree (GED).<\/li><li>3-5 years of industrial or heavy manufacturing electrical experience.<\/li><li>Proficiency in reading and interpreting complex schematics and control diagrams.<\/li><li>Familiarity with Rockwell, Siemens, or similar PLC platforms.<\/li><li>Licensed or certified as a journeyman electrician preferred.<\/li><li>Strong troubleshooting and decision-making skills.<\/li><li>High level of safety and quality.<\/li><li>Ability to multi-task at a fast-pace (at times), work in outside conditions during all seasons, climb multi-levels by stairs &amp; ladders, work from elevated platforms, use hand tools (shovel, hammer, wrenches, etc.).<\/li><li>Good problem-solving skills.<\/li><li>Mine Safety and Health (MSHA) Knowledge - Preferred.<\/li><li>Forklift experience - Preferred.<\/li><li>Computer Software - Preferred.<\/li><li>Warehouse experience - Preferred.<\/li><\/ul>","post_title":"Mining Plant Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/mining-plant-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Montpelier","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Montpelier, VA","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p>The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems. May mentor junior electricians.<\/p>\n<h2>Responsibilities<\/h2>\n<ul><li>Diagnose and repair high- and low-voltage systems, motor controls, and drives.<\/li><li>Install and maintain PLCs, VFDs, and control circuits.<\/li><li>Lead electrical projects and ensure code compliance.<\/li><li>Mentor Electrician I and II personnel and support cross-training.<\/li><li>Interface with automation, engineering, and maintenance teams.<\/li><li>Maintain technical documentation and update panel schematics.<\/li><li>Additional duties as assigned.<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>High school diploma or general education degree (GED).<\/li><li>3-5 years of industrial or heavy manufacturing electrical experience.<\/li><li>Proficiency in reading and interpreting complex schematics and control diagrams.<\/li><li>Familiarity with Rockwell, Siemens, or similar PLC platforms.<\/li><li>Licensed or certified as a journeyman electrician preferred.<\/li><li>Strong troubleshooting and decision-making skills.<\/li><li>High level of safety and quality.<\/li><li>Ability to multi-task at a fast-pace (at times), work in outside conditions during all seasons, climb multi-levels by stairs &amp; ladders, work from elevated platforms, use hand tools (shovel, hammer, wrenches, etc.).<\/li><li>Good problem-solving skills.<\/li><li>Mine Safety and Health (MSHA) Knowledge - Preferred.<\/li><li>Forklift experience - Preferred.<\/li><li>Computer Software - Preferred.<\/li><li>Warehouse experience - Preferred.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/6f7fb742c80d-mining-plant-electrician","%breezy_id%":"6f7fb742c80d","%breezy_friendly_id%":"6f7fb742c80d-mining-plant-electrician","%breezy_created_date%":"2026-01-14T15:13:14.403Z","%breezy_updated_date%":"2026-05-20T23:03:29.965Z","%_wpgmp_location_city%":"Montpelier","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Montpelier, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"37.8212538","%_wpgmp_metabox_longitude%":"-77.6844344","%rank_math_internal_links_processed%":"1"}},"id":3684,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Kershaw, South Carolina, USA Position Type: Full-Time About Us: Turner&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-2\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Kershaw, South Carolina, USA Position Type: Full-Time About Us: Turner&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Kershaw, South Carolina, USA Position Type: Full-Time About Us: Turner&hellip;","post_content":"<p><strong>Job Title:<\/strong> Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina, USA<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong>\nWe are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"High School or equivalent","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong> Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina, USA<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong>\nWe are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/2033ab5dd5b4-heavy-equipment-operator","%breezy_id%":"2033ab5dd5b4","%breezy_friendly_id%":"2033ab5dd5b4-heavy-equipment-operator","%breezy_created_date%":"2026-01-13T21:59:13.595Z","%breezy_updated_date%":"2026-05-20T20:11:51.360Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":3683,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Mining Company (Partnered with Turner Staffing Group) Location:&nbsp;Kershaw, SC Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining\/\" name=\"Haul Truck Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Mining Company (Partnered with Turner Staffing Group) Location:&nbsp;Kershaw, SC Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group is&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Mining Company (Partnered with Turner Staffing Group) Location:&nbsp;Kershaw, SC Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group is&hellip;","post_content":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Driver<\/p>\n<p><strong>Company:&nbsp;<\/strong>Mining Company (Partnered with Turner Staffing Group)<\/p>\n<p><strong>Location:<\/strong>&nbsp;Kershaw, SC<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group is proud to partner with a leading Mining Company in Kershaw, SC, dedicated to responsible and sustainable mining practices. Together, we are seeking a skilled and safety-conscious Haul Truck Driver to join the mining operations team. This is an exciting opportunity to contribute to the success of a well-established mining company committed to excellence and environmental stewardship.<\/p>\n<p><strong>Job Overview:<\/strong>&nbsp;As a Haul Truck Driver, you will play a crucial role in the transportation of materials within the mining site, ensuring the safe and efficient movement of material. The ideal candidate will have experience operating large haul trucks, a strong commitment to safety, and the ability to work in a dynamic mining environment.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Safe Operation of Haul Trucks:<\/strong><ul><li>Operate haul trucks to transport materials within the mining site.<\/li><li>Adhere to all safety protocols and guidelines to ensure a safe working environment.<\/li><\/ul><\/li><li><strong>Material Transportation:<\/strong><ul><li>Load, transport, and unload materials according to project specifications and production schedules.<\/li><li>Communicate effectively with equipment operators and supervisors to coordinate material movement.<\/li><\/ul><\/li><li><strong>Equipment Maintenance:<\/strong><ul><li>Conduct pre-shift inspections on haul trucks and report any issues to the maintenance team.<\/li><li>Ensure routine maintenance tasks are performed to keep equipment in optimal condition.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Follow safety procedures and guidelines to prevent accidents and injuries.<\/li><li>Participate in safety meetings and training sessions as required.<\/li><\/ul><\/li><li><strong>Record Keeping:<\/strong><ul><li>Maintain accurate records of material transported, distances covered, and fuel consumption.<\/li><li>Report any incidents or accidents promptly.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Articulating Haul Truck Driver in a mining or heavy equipment environment.<\/li><li>MSHA certificate preferred.&nbsp;<\/li><li>Knowledge of safe haul truck operation practices.<\/li><li>Ability to work in a physically demanding and outdoor environment.<\/li><li>Strong communication skills and the ability to work as part of a team.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","post_title":"Haul Truck Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"Unspecified","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Driver<\/p>\n<p><strong>Company:&nbsp;<\/strong>Mining Company (Partnered with Turner Staffing Group)<\/p>\n<p><strong>Location:<\/strong>&nbsp;Kershaw, SC<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group is proud to partner with a leading Mining Company in Kershaw, SC, dedicated to responsible and sustainable mining practices. Together, we are seeking a skilled and safety-conscious Haul Truck Driver to join the mining operations team. This is an exciting opportunity to contribute to the success of a well-established mining company committed to excellence and environmental stewardship.<\/p>\n<p><strong>Job Overview:<\/strong>&nbsp;As a Haul Truck Driver, you will play a crucial role in the transportation of materials within the mining site, ensuring the safe and efficient movement of material. The ideal candidate will have experience operating large haul trucks, a strong commitment to safety, and the ability to work in a dynamic mining environment.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Safe Operation of Haul Trucks:<\/strong><ul><li>Operate haul trucks to transport materials within the mining site.<\/li><li>Adhere to all safety protocols and guidelines to ensure a safe working environment.<\/li><\/ul><\/li><li><strong>Material Transportation:<\/strong><ul><li>Load, transport, and unload materials according to project specifications and production schedules.<\/li><li>Communicate effectively with equipment operators and supervisors to coordinate material movement.<\/li><\/ul><\/li><li><strong>Equipment Maintenance:<\/strong><ul><li>Conduct pre-shift inspections on haul trucks and report any issues to the maintenance team.<\/li><li>Ensure routine maintenance tasks are performed to keep equipment in optimal condition.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Follow safety procedures and guidelines to prevent accidents and injuries.<\/li><li>Participate in safety meetings and training sessions as required.<\/li><\/ul><\/li><li><strong>Record Keeping:<\/strong><ul><li>Maintain accurate records of material transported, distances covered, and fuel consumption.<\/li><li>Report any incidents or accidents promptly.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Articulating Haul Truck Driver in a mining or heavy equipment environment.<\/li><li>MSHA certificate preferred.&nbsp;<\/li><li>Knowledge of safe haul truck operation practices.<\/li><li>Ability to work in a physically demanding and outdoor environment.<\/li><li>Strong communication skills and the ability to work as part of a team.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/c918fc52f64c-haul-truck-operator-mining","%breezy_id%":"c918fc52f64c","%breezy_friendly_id%":"c918fc52f64c-haul-truck-operator-mining","%breezy_created_date%":"2026-01-13T21:57:58.188Z","%breezy_updated_date%":"2026-05-20T20:11:34.348Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":3682,"infowindow_disable":false},{"source":"post","title":"General Laborer &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Laborer &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 General Laborer Responsibilities:&nbsp; Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-2\/\" name=\"General Laborer &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 General Laborer Responsibilities:&nbsp; Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 General Laborer Responsibilities:&nbsp; Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 General Laborer<\/u><\/strong><br><\/p>\n<p><strong>Responsibilities:&nbsp;<\/strong><\/p>\n<ul><li>Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li><li>Duties include driving a truck, dumping loads, performing all pre-shift inspections, some basic maintenance and upkeep, and working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Staffing&nbsp;Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"General Laborer &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"Unspecified","%department%":"TSG","%description%":"<p><strong><u>Turner Staffing Group \u2013 General Laborer<\/u><\/strong><br><\/p>\n<p><strong>Responsibilities:&nbsp;<\/strong><\/p>\n<ul><li>Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li><li>Duties include driving a truck, dumping loads, performing all pre-shift inspections, some basic maintenance and upkeep, and working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Staffing&nbsp;Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/9b015675f185-general-laborer-mining","%breezy_id%":"9b015675f185","%breezy_friendly_id%":"9b015675f185-general-laborer-mining","%breezy_created_date%":"2026-01-13T21:55:23.334Z","%breezy_updated_date%":"2026-05-20T20:11:10.260Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":3681,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Excavator Operator Location: Kershaw, South Carolina About Us: Turner Staffing Group is a leading staffing agency dedicated to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-2\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Excavator Operator Location: Kershaw, South Carolina About Us: Turner Staffing Group is a leading staffing agency dedicated to&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Excavator Operator Location: Kershaw, South Carolina About Us: Turner Staffing Group is a leading staffing agency dedicated to&hellip;","post_content":"<p><strong>Job Title: Excavator Operator<\/strong><br><\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Kershaw, South Carolina. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Kershaw, South Carolina. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong> Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong> Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong> Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong> Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong> Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"High School or equivalent","%department%":"TSG","%description%":"<p><strong>Job Title: Excavator Operator<\/strong><br><\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Kershaw, South Carolina. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Kershaw, South Carolina. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong> Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong> Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong> Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong> Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong> Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/14a7b7187a6a-excavator-operator","%breezy_id%":"14a7b7187a6a","%breezy_friendly_id%":"14a7b7187a6a-excavator-operator","%breezy_created_date%":"2026-01-13T21:54:59.024Z","%breezy_updated_date%":"2026-05-20T20:10:50.272Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":3680,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Montpelier, Virginia Position Type: Full-Time About Us: Turner Staffing Group,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Montpelier, Virginia Position Type: Full-Time About Us: Turner Staffing Group,&hellip;","address":"Montpelier, VA, USA","location":{"lat":"37.8212538","city":"Montpelier","state":"VA","country":"United States","lng":"-77.6844344","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Montpelier, Virginia Position Type: Full-Time About Us: Turner Staffing Group,&hellip;","post_content":"<p><strong>Job Title:<\/strong> Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong> Montpelier, Virginia<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group, in collaboration with our esteemed mining partner in Montpelier, Virginia, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong>\nWe are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Montpelier","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Montpelier, VA","%education%":"Unspecified","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong> Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong> Montpelier, Virginia<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group, in collaboration with our esteemed mining partner in Montpelier, Virginia, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong>\nWe are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3b39cb35fdd2-heavy-equipment-operator","%breezy_id%":"3b39cb35fdd2","%breezy_friendly_id%":"3b39cb35fdd2-heavy-equipment-operator","%breezy_created_date%":"2025-06-26T20:34:37.909Z","%breezy_updated_date%":"2026-05-20T23:02:37.235Z","%_wpgmp_location_city%":"Montpelier","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Montpelier, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"37.8212538","%_wpgmp_metabox_longitude%":"-77.6844344","%rank_math_internal_links_processed%":"1"}},"id":3679,"infowindow_disable":false},{"source":"post","title":"Remote Telecommunications Lineman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Remote Telecommunications Lineman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Summary The Remote Telecommunications Lineman \u2013 Asset Review &amp; Flight Planning role supports telecom infrastructure projects by assisting in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/remote-telecommunications-lineman\/\" name=\"Remote Telecommunications Lineman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Summary The Remote Telecommunications Lineman \u2013 Asset Review &amp; Flight Planning role supports telecom infrastructure projects by assisting in&hellip;","address":"San Antonio, TX, USA","location":{"lat":"29.4251905","city":"San Antonio","state":"TX","country":"United States","lng":"-98.4945922","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/remote-telecommunications-lineman\/","zoom":19,"extra_fields":{"post_excerpt":"Position Summary The Remote Telecommunications Lineman \u2013 Asset Review &amp; Flight Planning role supports telecom infrastructure projects by assisting in&hellip;","post_content":"<p><strong>Position Summary<\/strong><\/p>\n<p>The Remote Telecommunications Lineman \u2013 Asset Review &amp; Flight Planning role supports<\/p>\n<p>telecom infrastructure projects by assisting in planning field data capture activities and<\/p>\n<p>reviewing client assets using imagery collected by field teams. This position leverages real-<\/p>\n<p>world lineman experience to ensure accurate flight planning, proper data handling, and<\/p>\n<p>high-quality asset identification and validation in accordance with client and industry<\/p>\n<p>standards. This is a 90% remote, desk-based role with no field work required.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Key Responsibilities<\/strong><\/p>\n<p>Flight Planning &amp; Field Support<\/p>\n<p>\uf0b7 Assist in flight planning for data capture activities<\/p>\n<p>\uf0b7 Verify scope alignment with client requirements<\/p>\n<p>\uf0b7 Identify access, clearance, or environmental constraints<\/p>\n<p>\uf0b7 Coordinate with operations on capture expectations and priorities<\/p>\n<p>\uf0b7 Review incoming data for completeness and usability<\/p>\n<p>\uf0b7 Identify gaps requiring re-capture before processing<\/p>\n<p>Data Upload &amp; Management<\/p>\n<p>\uf0b7 Upload field-captured imagery and datasets to designated platforms<\/p>\n<p>\uf0b7 Organize, label, and track datasets for version control<\/p>\n<p>\uf0b7 Validate file integrity and metadata completeness<\/p>\n<p>\uf0b7 Maintain data organization standards for efficient QA review<\/p>\n<p>Asset Review &amp; Validation<\/p>\n<p>\uf0b7 Review ground, aerial, and pole-mounted imagery<\/p>\n<p>\uf0b7 Identify and classify telecom assets (fiber, copper, coax, strand)<\/p>\n<p>\uf0b7 Validate attachment order and construction practices<\/p>\n<p>\uf0b7 Interpret field conditions using lineman expertise<\/p>\n<p>\uf0b7 Flag discrepancies, safety concerns, or unclear imagery<\/p>\n<p>\uf0b7 Enter and update asset data in client platforms<\/p>\n<p>\uf0b7 Communicate findings with supervisors and project teams<\/p>\n<p>\uf0b7 Meet production and quality benchmarks<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Required Qualifications<\/strong><\/p>\n<p>\uf0b7 Prior experience as a telecommunications lineman or OSP technician<\/p>\n<p>\uf0b7 Strong understanding of aerial and underground infrastructure<\/p>\n<p>\uf0b7 Ability to interpret construction practices from imagery<\/p>\n<p>\uf0b7 Experience or aptitude in planning operational workflows<\/p>\n<p>\uf0b7 Proficiency with computers and web-based platforms<\/p>\n<p>\uf0b7 High attention to detail and documentation accuracy<\/p>\n<p>\uf0b7 Ability to work independently in a remote environment<\/p>\n<p>\uf0b7 Reliable internet connection and workspace<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Preferred Qualifications<\/strong><\/p>\n<p>\uf0b7 Experience with telecom asset inventories or make-ready<\/p>\n<p>\uf0b7 Familiarity with major carrier standards<\/p>\n<p>\uf0b7 Experience with drone or LiDAR imagery workflows<\/p>\n<p>\uf0b7 QA\/QC or back-office telecom experience<\/p>\n<p>\uf0b7 Knowledge of NESC or GO95 standards<\/p>\n<p>\uf0b7 Experience with GIS or asset management systems<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Work Environment &amp; Schedule<\/strong><\/p>\n<p>Fully remote, desk-based role with standard business hours. Overtime may be required<\/p>\n<p>based on project demand. Production-based workflow with quality benchmarks.<\/p>\n<p>Physical Requirements<\/p>\n<p>Ability to sit and work at a computer for extended periods and visually review detailed<\/p>\n<p>imagery and data.<\/p>","post_title":"Remote Telecommunications Lineman","post_link":"https:\/\/turnerstaffing.com\/position\/remote-telecommunications-lineman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"San Antonio","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"San Antonio, TX","%education%":"","%department%":"TSG","%description%":"<p><strong>Position Summary<\/strong><\/p>\n<p>The Remote Telecommunications Lineman \u2013 Asset Review &amp; Flight Planning role supports<\/p>\n<p>telecom infrastructure projects by assisting in planning field data capture activities and<\/p>\n<p>reviewing client assets using imagery collected by field teams. This position leverages real-<\/p>\n<p>world lineman experience to ensure accurate flight planning, proper data handling, and<\/p>\n<p>high-quality asset identification and validation in accordance with client and industry<\/p>\n<p>standards. This is a 90% remote, desk-based role with no field work required.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Key Responsibilities<\/strong><\/p>\n<p>Flight Planning &amp; Field Support<\/p>\n<p>\uf0b7 Assist in flight planning for data capture activities<\/p>\n<p>\uf0b7 Verify scope alignment with client requirements<\/p>\n<p>\uf0b7 Identify access, clearance, or environmental constraints<\/p>\n<p>\uf0b7 Coordinate with operations on capture expectations and priorities<\/p>\n<p>\uf0b7 Review incoming data for completeness and usability<\/p>\n<p>\uf0b7 Identify gaps requiring re-capture before processing<\/p>\n<p>Data Upload &amp; Management<\/p>\n<p>\uf0b7 Upload field-captured imagery and datasets to designated platforms<\/p>\n<p>\uf0b7 Organize, label, and track datasets for version control<\/p>\n<p>\uf0b7 Validate file integrity and metadata completeness<\/p>\n<p>\uf0b7 Maintain data organization standards for efficient QA review<\/p>\n<p>Asset Review &amp; Validation<\/p>\n<p>\uf0b7 Review ground, aerial, and pole-mounted imagery<\/p>\n<p>\uf0b7 Identify and classify telecom assets (fiber, copper, coax, strand)<\/p>\n<p>\uf0b7 Validate attachment order and construction practices<\/p>\n<p>\uf0b7 Interpret field conditions using lineman expertise<\/p>\n<p>\uf0b7 Flag discrepancies, safety concerns, or unclear imagery<\/p>\n<p>\uf0b7 Enter and update asset data in client platforms<\/p>\n<p>\uf0b7 Communicate findings with supervisors and project teams<\/p>\n<p>\uf0b7 Meet production and quality benchmarks<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Required Qualifications<\/strong><\/p>\n<p>\uf0b7 Prior experience as a telecommunications lineman or OSP technician<\/p>\n<p>\uf0b7 Strong understanding of aerial and underground infrastructure<\/p>\n<p>\uf0b7 Ability to interpret construction practices from imagery<\/p>\n<p>\uf0b7 Experience or aptitude in planning operational workflows<\/p>\n<p>\uf0b7 Proficiency with computers and web-based platforms<\/p>\n<p>\uf0b7 High attention to detail and documentation accuracy<\/p>\n<p>\uf0b7 Ability to work independently in a remote environment<\/p>\n<p>\uf0b7 Reliable internet connection and workspace<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Preferred Qualifications<\/strong><\/p>\n<p>\uf0b7 Experience with telecom asset inventories or make-ready<\/p>\n<p>\uf0b7 Familiarity with major carrier standards<\/p>\n<p>\uf0b7 Experience with drone or LiDAR imagery workflows<\/p>\n<p>\uf0b7 QA\/QC or back-office telecom experience<\/p>\n<p>\uf0b7 Knowledge of NESC or GO95 standards<\/p>\n<p>\uf0b7 Experience with GIS or asset management systems<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Work Environment &amp; Schedule<\/strong><\/p>\n<p>Fully remote, desk-based role with standard business hours. Overtime may be required<\/p>\n<p>based on project demand. Production-based workflow with quality benchmarks.<\/p>\n<p>Physical Requirements<\/p>\n<p>Ability to sit and work at a computer for extended periods and visually review detailed<\/p>\n<p>imagery and data.<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/e57b1b935535-remote-telecommunications-lineman","%breezy_id%":"e57b1b935535","%breezy_friendly_id%":"e57b1b935535-remote-telecommunications-lineman","%breezy_created_date%":"2026-05-20T11:57:39.101Z","%breezy_updated_date%":"2026-05-20T12:53:03.205Z","%_wpgmp_location_city%":"San Antonio","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"San Antonio, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.4251905","%_wpgmp_metabox_longitude%":"-98.4945922","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"283"}},"id":3677,"infowindow_disable":false},{"source":"post","title":"Electric Utilities Data Processor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electric Utilities Data Processor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    As an Electric Utilities Data Processor, you are tasked with operational excellence. You will work with the Data and Processing&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electric-utilities-data-processor\/\" name=\"Electric Utilities Data Processor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"As an Electric Utilities Data Processor, you are tasked with operational excellence. You will work with the Data and Processing&hellip;","address":"San Antonio, TX, USA","location":{"lat":"29.4251905","city":"San Antonio","state":"TX","country":"United States","lng":"-98.4945922","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electric-utilities-data-processor\/","zoom":19,"extra_fields":{"post_excerpt":"As an Electric Utilities Data Processor, you are tasked with operational excellence. You will work with the Data and Processing&hellip;","post_content":"<p>As an Electric Utilities Data Processor, you are tasked with operational excellence. You will work with the Data and Processing Manager and Program Manager to formulate and execute upstream, midstream, and downstream data management strategies for electric utilities projects.<\/p>\n<p><\/p>\n<p><strong>Your duties and responsibilities include, but are not limited to:<\/strong><\/p>\n<p>\u2022&nbsp;<strong>Preparing Data:<\/strong>&nbsp;Verify and review data received from data controllers to ensure accuracy, relevance, and completeness.<\/p>\n<p>\u2022&nbsp;<strong>Inputting Data:<\/strong>&nbsp;Enter data into relevant software systems, ensuring there are no errors, and the data is correctly translated for analysis.<\/p>\n<p>\u2022&nbsp;<strong>Organizing Data:<\/strong>&nbsp;Create graphs, charts, and reports to help data controllers understand the data, providing context and insights.<\/p>\n<p>\u2022&nbsp;<strong>Storing Data:<\/strong>&nbsp;Maintain both raw and processed data securely, ensuring it is accessible for future use and analysis.<\/p>\n<p>\u2022&nbsp;<strong>Intermediary Role:<\/strong>&nbsp;Act as a liaison between data subjects and data controllers, converting raw data into readable formats.<\/p>\n<p>\u2022&nbsp;<strong>Designing IT Systems:<\/strong>&nbsp;Assist in creating and modifying IT systems to gather and process data efficiently, ensuring compliance with data protection regulations.<\/p>\n<p><\/p>\n<p><strong>Required Qualifications:<\/strong><\/p>\n<p>\u2022 English<\/p>\n<p>\u2022 Ability to verify and validate incoming data for completeness<\/p>\n<p>\u2022 Proficiency with Microsoft Suite (specifically, Excel)<\/p>\n<p>\u2022 Experience working with data management and analytics platforms<\/p>\n<p>\u2022 Ability to communicate upstream, downstream, and laterally with peers, superiors, and other departments<\/p>\n<p>\u2022 Familiar with secure data storage, ability to follow established data security protocols<\/p>\n<p>\u2022 Ability to adapt current experience to new systems<\/p>\n<p>\u2022 Ability to follow existing SOPs<\/p>\n<p>\u2022 Proven ability to work independently&nbsp;<\/p>\n<p>\u2022 Attention to detail<\/p>\n<p>\u2022 Ability to work non-standard hours as required<\/p>\n<p><\/p>\n<p><strong>Bonus:<\/strong><\/p>\n<p>\u2022 Experience with various GIS platforms<\/p>\n<p>\u2022 familiarity with remote collaboration tools<\/p>\n<p>\u2022 experience in telecom, utility, or infrastructure<\/p>","post_title":"Electric Utilities Data Processor","post_link":"https:\/\/turnerstaffing.com\/position\/electric-utilities-data-processor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"San Antonio","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"San Antonio, TX","%education%":"","%department%":"TSG","%description%":"<p>As an Electric Utilities Data Processor, you are tasked with operational excellence. You will work with the Data and Processing Manager and Program Manager to formulate and execute upstream, midstream, and downstream data management strategies for electric utilities projects.<\/p>\n<p><\/p>\n<p><strong>Your duties and responsibilities include, but are not limited to:<\/strong><\/p>\n<p>\u2022&nbsp;<strong>Preparing Data:<\/strong>&nbsp;Verify and review data received from data controllers to ensure accuracy, relevance, and completeness.<\/p>\n<p>\u2022&nbsp;<strong>Inputting Data:<\/strong>&nbsp;Enter data into relevant software systems, ensuring there are no errors, and the data is correctly translated for analysis.<\/p>\n<p>\u2022&nbsp;<strong>Organizing Data:<\/strong>&nbsp;Create graphs, charts, and reports to help data controllers understand the data, providing context and insights.<\/p>\n<p>\u2022&nbsp;<strong>Storing Data:<\/strong>&nbsp;Maintain both raw and processed data securely, ensuring it is accessible for future use and analysis.<\/p>\n<p>\u2022&nbsp;<strong>Intermediary Role:<\/strong>&nbsp;Act as a liaison between data subjects and data controllers, converting raw data into readable formats.<\/p>\n<p>\u2022&nbsp;<strong>Designing IT Systems:<\/strong>&nbsp;Assist in creating and modifying IT systems to gather and process data efficiently, ensuring compliance with data protection regulations.<\/p>\n<p><\/p>\n<p><strong>Required Qualifications:<\/strong><\/p>\n<p>\u2022 English<\/p>\n<p>\u2022 Ability to verify and validate incoming data for completeness<\/p>\n<p>\u2022 Proficiency with Microsoft Suite (specifically, Excel)<\/p>\n<p>\u2022 Experience working with data management and analytics platforms<\/p>\n<p>\u2022 Ability to communicate upstream, downstream, and laterally with peers, superiors, and other departments<\/p>\n<p>\u2022 Familiar with secure data storage, ability to follow established data security protocols<\/p>\n<p>\u2022 Ability to adapt current experience to new systems<\/p>\n<p>\u2022 Ability to follow existing SOPs<\/p>\n<p>\u2022 Proven ability to work independently&nbsp;<\/p>\n<p>\u2022 Attention to detail<\/p>\n<p>\u2022 Ability to work non-standard hours as required<\/p>\n<p><\/p>\n<p><strong>Bonus:<\/strong><\/p>\n<p>\u2022 Experience with various GIS platforms<\/p>\n<p>\u2022 familiarity with remote collaboration tools<\/p>\n<p>\u2022 experience in telecom, utility, or infrastructure<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b3f9dea6129c-electric-utilities-data-processor","%breezy_id%":"b3f9dea6129c","%breezy_friendly_id%":"b3f9dea6129c-electric-utilities-data-processor","%breezy_created_date%":"2026-05-20T11:55:05.107Z","%breezy_updated_date%":"2026-05-20T12:52:24.971Z","%_wpgmp_location_city%":"San Antonio","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"San Antonio, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.4251905","%_wpgmp_metabox_longitude%":"-98.4945922","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"282"}},"id":3676,"infowindow_disable":false},{"source":"post","title":"Field Service Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the Fargo,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-crushing-screening-equipment\/\" name=\"Field Service Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the Fargo,&hellip;","address":"Fargo, ND, USA","location":{"lat":"46.8771863","city":"Fargo","state":"ND","country":"United States","lng":"-96.7898034","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-crushing-screening-equipment\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are hiring a Field Service Technician to support a growing mining and aggregate operation in the Fargo,&hellip;","post_content":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the Fargo, ND area. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","post_title":"Field Service Technician","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-crushing-screening-equipment\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Fargo","%location_state_id%":"ND","%location_state_name%":"North Dakota","%location_city_state%":"Fargo, ND","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are hiring a <strong>Field Service Technician<\/strong> to support a growing mining and aggregate operation in the Fargo, ND area. This is an excellent opportunity for mechanically inclined individuals looking to build a long-term career working with crushing and screening equipment in real production environments.<\/p>\n<p>This role is ideal for someone who is motivated, hands-on, and eager to learn. You do not need decades of experience\u2014what matters most is your attitude, work ethic, and willingness to grow. As the company expands, this position offers strong advancement potential into senior technician or leadership roles.<\/p>\n<h3><strong>What Makes This Opportunity Unique<\/strong><\/h3>\n<ul>\n<li>\nJoin a rapidly growing operation with aggressive expansion plans\n<\/li>\n<li>\nHands-on training with advanced crushing and screening equipment\n<\/li>\n<li>\nClear path for career growth and advancement\n<\/li>\n<li>\nWork directly with experienced technicians, leadership, and customers\n<\/li>\n<li>\nGain real-world field experience in high-production environments\n<\/li>\n<\/ul>\n<h3><strong>What You\u2019ll Work On<\/strong><\/h3>\n<ul>\n<li>\nJaw, cone, and impact crushers\n<\/li>\n<li>\nScreening plants and scalping screens\n<\/li>\n<li>\nConveyors, feeders, and material handling systems\n<\/li>\n<li>\nHydraulic systems and components\n<\/li>\n<li>\nDiesel engines and power units\n<\/li>\n<li>\nPreventative maintenance, shutdowns, repairs, and rebuilds\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with diagnostics, troubleshooting, and repair of crushing and screening equipment\n<\/li>\n<li>\nPerform preventative maintenance, inspections, and routine service work\n<\/li>\n<li>\nSupport equipment installations, start-ups, and commissioning\n<\/li>\n<li>\nComplete Pre-Delivery Inspections (PDIs) on new equipment\n<\/li>\n<li>\nLearn to diagnose mechanical, hydraulic, and operational issues\n<\/li>\n<li>\nWork directly with customers and plant personnel in the field\n<\/li>\n<li>\nComplete service reports and maintain accurate documentation\n<\/li>\n<li>\nDevelop into a trusted technician capable of working independently\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>\nBasic experience with mechanical systems (aggregate equipment experience preferred but not required)\n<\/li>\n<li>\nStrong mechanical aptitude and willingness to learn\n<\/li>\n<li>\nSelf-motivated with the ability to work independently in the field\n<\/li>\n<li>\nPositive attitude and strong work ethic\n<\/li>\n<li>\nValid driver\u2019s license\n<\/li>\n<li>\nWillingness to travel regionally, including occasional overnight stays\n<\/li>\n<\/ul>\n<p><strong>Preferred (Not Required)<\/strong><\/p>\n<ul>\n<li>\nExperience in aggregate, mining, or heavy equipment industries\n<\/li>\n<li>\nFamiliarity with crushing, screening, or conveyor systems\n<\/li>\n<li>\nHydraulic and\/or diesel engine experience\n<\/li>\n<li>\nWelding or fabrication skills\n<\/li>\n<li>\nMSHA site experience\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nPrimarily field-based role supporting active mining and aggregate operations\n<\/li>\n<li>\nExposure to outdoor conditions, including heat, dust, noise, and heavy equipment\n<\/li>\n<li>\nFrequent travel to customer and job sites throughout the region<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/dd5b186f6179-field-service-technician","%breezy_id%":"dd5b186f6179","%breezy_friendly_id%":"dd5b186f6179-field-service-technician","%breezy_created_date%":"2026-03-30T17:43:32.592Z","%breezy_updated_date%":"2026-05-29T17:13:12.345Z","%_wpgmp_location_city%":"Fargo","%_wpgmp_location_state%":"ND","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fargo, ND, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"46.8771863","%_wpgmp_metabox_longitude%":"-96.7898034","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"275"}},"id":3674,"infowindow_disable":false},{"source":"post","title":"Production Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Production Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is seeking an experienced Production Geologist to support and advance geological evaluation, grade control, and resource development activities&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/production-geologist\/\" name=\"Production Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is seeking an experienced Production Geologist to support and advance geological evaluation, grade control, and resource development activities&hellip;","address":"Elko, NVUnited States","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/production-geologist\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is seeking an experienced Production Geologist to support and advance geological evaluation, grade control, and resource development activities&hellip;","post_content":"<p>Our client is seeking an experienced Production Geologist to support and advance geological evaluation, grade control, and resource development activities at the Jerritt Canyon operation. This role works closely with Geology, Technical Services, and Operations teams to deliver accurate and actionable geological information that supports safe, efficient, and data-driven mining decisions.<\/p><p>Depending on experience, this individual may take on increasing responsibility in grade control leadership, resource model support, and drilling program coordination while contributing to continuous improvement initiatives across the operation.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Support and\/or lead grade control programs to optimize ore recovery and minimize dilution <\/li><li>Collect, interpret, and analyze geological data including mapping, sampling, and core logging <\/li><li>Support and coordinate drilling and grade control programs while ensuring safe and efficient execution <\/li><li>Update, maintain, and validate geological and resource models using drilling and sampling data <\/li><li>Perform geological interpretation and targeting to support mine planning and resource development initiatives <\/li><li>Maintain QA\/QC standards and ensure geological data integrity <\/li><li>Maintain and improve geological databases and modeling systems <\/li><li>Provide geological input for mine planning, production activities, and development projects <\/li><li>Participate in reconciliation processes and identify opportunities to improve grade control performance <\/li><li>Identify geological risks and opportunities to support mine and drill planning activities <\/li><li>Support evaluation of exploration targets, new properties, and development opportunities <\/li><li>Develop recommendations to improve operational performance and geological understanding <\/li><li>Contribute to building geological knowledge across the site and surrounding district <\/li><li>Mentor and support junior team members as appropriate<\/li><li>Other duties as assigned.<\/li><\/ul><p><strong>Qualifications<\/strong><\/p><ul><li>Bachelor&rsquo;s degree in Geology or related discipline, or equivalent industry experience <\/li><li>5&ndash;8+ years of experience in mining geology, exploration, or related mining environments <\/li><li>Underground mining experience preferred, particularly in narrow vein or similar deposit types <\/li><li>Strong understanding of grade control practices, geological modeling, and reconciliation processes <\/li><li>Experience supporting or leading drilling programs and geological data collection <\/li><li>Proficiency with geological modeling and mining software; Deswik experience preferred <\/li><li>Strong analytical, problem-solving, and data interpretation skills <\/li><li>Ability to communicate effectively across technical and operational teams <\/li><li>Professional Geologist (PG) registration or eligibility is considered an asset <\/li><li>Demonstrated commitment to safety, operational excellence, and continuous improvement <\/li><\/ul><p><strong>Why Apply<\/strong><\/p><p>This is an opportunity to join a technically driven mining operation during an exciting phase of evaluation and development. The successful candidate will play a meaningful role in shaping geological understanding and supporting future operational success at a well-established Nevada gold asset.<\/p><p><strong>Equal Opportunity Employer<\/strong><\/p><p>Our client is an equal opportunity employer committed to creating an inclusive workplace and providing employment opportunities in accordance with all applicable laws.<\/p><p><strong>Work Authorization<\/strong><\/p><p>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/p>","post_title":"Production Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/production-geologist\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_city_state%":"Elko, NV","%description%":"<p>Our client is seeking an experienced Production Geologist to support and advance geological evaluation, grade control, and resource development activities at the Jerritt Canyon operation. This role works closely with Geology, Technical Services, and Operations teams to deliver accurate and actionable geological information that supports safe, efficient, and data-driven mining decisions.<\/p><p>Depending on experience, this individual may take on increasing responsibility in grade control leadership, resource model support, and drilling program coordination while contributing to continuous improvement initiatives across the operation.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Support and\/or lead grade control programs to optimize ore recovery and minimize dilution <\/li><li>Collect, interpret, and analyze geological data including mapping, sampling, and core logging <\/li><li>Support and coordinate drilling and grade control programs while ensuring safe and efficient execution <\/li><li>Update, maintain, and validate geological and resource models using drilling and sampling data <\/li><li>Perform geological interpretation and targeting to support mine planning and resource development initiatives <\/li><li>Maintain QA\/QC standards and ensure geological data integrity <\/li><li>Maintain and improve geological databases and modeling systems <\/li><li>Provide geological input for mine planning, production activities, and development projects <\/li><li>Participate in reconciliation processes and identify opportunities to improve grade control performance <\/li><li>Identify geological risks and opportunities to support mine and drill planning activities <\/li><li>Support evaluation of exploration targets, new properties, and development opportunities <\/li><li>Develop recommendations to improve operational performance and geological understanding <\/li><li>Contribute to building geological knowledge across the site and surrounding district <\/li><li>Mentor and support junior team members as appropriate<\/li><li>Other duties as assigned.<\/li><\/ul><p><strong>Qualifications<\/strong><\/p><ul><li>Bachelor&rsquo;s degree in Geology or related discipline, or equivalent industry experience <\/li><li>5&ndash;8+ years of experience in mining geology, exploration, or related mining environments <\/li><li>Underground mining experience preferred, particularly in narrow vein or similar deposit types <\/li><li>Strong understanding of grade control practices, geological modeling, and reconciliation processes <\/li><li>Experience supporting or leading drilling programs and geological data collection <\/li><li>Proficiency with geological modeling and mining software; Deswik experience preferred <\/li><li>Strong analytical, problem-solving, and data interpretation skills <\/li><li>Ability to communicate effectively across technical and operational teams <\/li><li>Professional Geologist (PG) registration or eligibility is considered an asset <\/li><li>Demonstrated commitment to safety, operational excellence, and continuous improvement <\/li><\/ul><p><strong>Why Apply<\/strong><\/p><p>This is an opportunity to join a technically driven mining operation during an exciting phase of evaluation and development. The successful candidate will play a meaningful role in shaping geological understanding and supporting future operational success at a well-established Nevada gold asset.<\/p><p><strong>Equal Opportunity Employer<\/strong><\/p><p>Our client is an equal opportunity employer committed to creating an inclusive workplace and providing employment opportunities in accordance with all applicable laws.<\/p><p><strong>Work Authorization<\/strong><\/p><p>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/po4zt81byt1s8xki9wjdrg7yic","%crelate_id%":"po4zt81byt1s8xki9wjdrg7yic","%crelate_created_date%":"2026-05-19T18:16:42.57Z","%crelate_updated_date%":"2026-05-26T22:46:16.95Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NVUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":3655,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling-4\/\" name=\"Haul Truck Operator &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;","address":"Tonopah, NV, USA","location":{"lat":"38.069211","city":"Tonopah","state":"NV","country":"United States","lng":"-117.2305861","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling-4\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;","post_content":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Operator<br>\n<strong>Schedule:<\/strong> 12-hour shifts<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and safety-focused <strong>Haul Truck Operator<\/strong> to join our mining operations team. This role is responsible for safely operating heavy haul trucks in an active mine environment to transport material efficiently and in accordance with site safety standards. The ideal candidate will have a minimum of 2 years of experience operating <strong>40-ton to 100-ton haul trucks<\/strong> and must be willing to work 12-hour shifts, and be open to&nbsp;day and night schedules.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSafely operate mine haul trucks in an active mining environment\n<\/li>\n<li>\nTransport materials efficiently to designated locations\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nReport mechanical issues, safety concerns, or unsafe conditions immediately\n<\/li>\n<li>\nFollow all site safety procedures, traffic patterns, and operational rules\n<\/li>\n<li>\nCommunicate effectively with supervisors, dispatch, and other equipment operators\n<\/li>\n<li>\nMaintain productivity while operating equipment safely and responsibly\n<\/li>\n<li>\nAssist with other duties as needed to support site operations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of <strong>2 years of experience<\/strong> operating <strong>40-ton to 100-ton haul trucks<\/strong>\n<\/li>\n<li>\nPrevious mining or heavy civil experience preferred\n<\/li>\n<li>\nMust be able to work <strong>12-hour shifts<\/strong>\n<\/li>\n<li>\nMust be open to <strong>day and night shift schedules<\/strong>\n<\/li>\n<li>\nStrong understanding of safe equipment operation and site awareness\n<\/li>\n<li>\n<strong>MSHA certification preferred<\/strong>\n<\/li>\n<li>\nValid driver\u2019s license&nbsp;<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibration, and varying weather conditions\n<\/li>\n<li>\nWork around heavy equipment, trucks, and active site traffic\n<\/li>\n<li>\nPhysically demanding role requiring attention to detail and strong safety awareness<\/li><\/ul>","post_title":"Haul Truck Operator &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Tonopah","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Tonopah, NV","%education%":"","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Operator<br>\n<strong>Schedule:<\/strong> 12-hour shifts<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and safety-focused <strong>Haul Truck Operator<\/strong> to join our mining operations team. This role is responsible for safely operating heavy haul trucks in an active mine environment to transport material efficiently and in accordance with site safety standards. The ideal candidate will have a minimum of 2 years of experience operating <strong>40-ton to 100-ton haul trucks<\/strong> and must be willing to work 12-hour shifts, and be open to&nbsp;day and night schedules.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSafely operate mine haul trucks in an active mining environment\n<\/li>\n<li>\nTransport materials efficiently to designated locations\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nReport mechanical issues, safety concerns, or unsafe conditions immediately\n<\/li>\n<li>\nFollow all site safety procedures, traffic patterns, and operational rules\n<\/li>\n<li>\nCommunicate effectively with supervisors, dispatch, and other equipment operators\n<\/li>\n<li>\nMaintain productivity while operating equipment safely and responsibly\n<\/li>\n<li>\nAssist with other duties as needed to support site operations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of <strong>2 years of experience<\/strong> operating <strong>40-ton to 100-ton haul trucks<\/strong>\n<\/li>\n<li>\nPrevious mining or heavy civil experience preferred\n<\/li>\n<li>\nMust be able to work <strong>12-hour shifts<\/strong>\n<\/li>\n<li>\nMust be open to <strong>day and night shift schedules<\/strong>\n<\/li>\n<li>\nStrong understanding of safe equipment operation and site awareness\n<\/li>\n<li>\n<strong>MSHA certification preferred<\/strong>\n<\/li>\n<li>\nValid driver\u2019s license&nbsp;<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibration, and varying weather conditions\n<\/li>\n<li>\nWork around heavy equipment, trucks, and active site traffic\n<\/li>\n<li>\nPhysically demanding role requiring attention to detail and strong safety awareness<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a18b5139d899-haul-truck-operator-traveling","%breezy_id%":"a18b5139d899","%breezy_friendly_id%":"a18b5139d899-haul-truck-operator-traveling","%breezy_created_date%":"2026-05-19T15:44:44.706Z","%breezy_updated_date%":"2026-05-19T15:45:01.273Z","%_wpgmp_location_city%":"Tonopah","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tonopah, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.069211","%_wpgmp_metabox_longitude%":"-117.2305861","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"280"}},"id":3653,"infowindow_disable":false},{"source":"post","title":"Mining Foreman &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Foreman &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-foreman-traveling-3\/\" name=\"Mining Foreman &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;","address":"Tonopah, NV, USA","location":{"lat":"38.069211","city":"Tonopah","state":"NV","country":"United States","lng":"-117.2305861","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-foreman-traveling-3\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety, and operational excellence. We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nSupervise and direct daily activities of mining crews, equipment operators, and labor personnel\n<\/li>\n<li>\nCoordinate production schedules to meet daily and weekly output targets\n<\/li>\n<li>\nMonitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures\n<\/li>\n<li>\nEnforce mine safety standards, company policies, and MSHA regulations at all times\n<\/li>\n<li>\nConduct pre-shift meetings, safety briefings, and crew assignments\n<\/li>\n<li>\nInspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies\n<\/li>\n<li>\nCommunicate with management regarding production progress, staffing needs, and operational concerns\n<\/li>\n<li>\nEnsure equipment is being operated properly and maintenance issues are reported promptly\n<\/li>\n<li>\nTrain and mentor crew members on safe work practices and operational procedures\n<\/li>\n<li>\nMaintain accurate shift reports, production logs, and incident documentation\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious supervisory experience in mining operations required\n<\/li>\n<li>\nStrong knowledge of surface or underground mining processes (depending on site application)\n<\/li>\n<li>\nExperience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers\n<\/li>\n<li>\nMSHA certification required or ability to obtain\/maintain certification as required by site\n<\/li>\n<li>\nProven leadership, communication, and decision-making skills\n<\/li>\n<li>\nAbility to prioritize tasks and manage multiple crews in a fast-paced environment\n<\/li>\n<li>\nStrong understanding of workplace safety and hazard recognition practices\n<\/li>\n<li>\nProficient in basic reporting, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to work in active mining environments, including exposure to dust, noise, and varying weather conditions\n<\/li>\n<li>\nAbility to walk uneven terrain, climb equipment\/access points, and remain active throughout shift\n<\/li>\n<li>\nAbility to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to wear all required PPE on site<\/li><\/ul>","post_title":"Mining Foreman &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/mining-foreman-traveling-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Tonopah","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Tonopah, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety, and operational excellence. We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nSupervise and direct daily activities of mining crews, equipment operators, and labor personnel\n<\/li>\n<li>\nCoordinate production schedules to meet daily and weekly output targets\n<\/li>\n<li>\nMonitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures\n<\/li>\n<li>\nEnforce mine safety standards, company policies, and MSHA regulations at all times\n<\/li>\n<li>\nConduct pre-shift meetings, safety briefings, and crew assignments\n<\/li>\n<li>\nInspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies\n<\/li>\n<li>\nCommunicate with management regarding production progress, staffing needs, and operational concerns\n<\/li>\n<li>\nEnsure equipment is being operated properly and maintenance issues are reported promptly\n<\/li>\n<li>\nTrain and mentor crew members on safe work practices and operational procedures\n<\/li>\n<li>\nMaintain accurate shift reports, production logs, and incident documentation\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious supervisory experience in mining operations required\n<\/li>\n<li>\nStrong knowledge of surface or underground mining processes (depending on site application)\n<\/li>\n<li>\nExperience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers\n<\/li>\n<li>\nMSHA certification required or ability to obtain\/maintain certification as required by site\n<\/li>\n<li>\nProven leadership, communication, and decision-making skills\n<\/li>\n<li>\nAbility to prioritize tasks and manage multiple crews in a fast-paced environment\n<\/li>\n<li>\nStrong understanding of workplace safety and hazard recognition practices\n<\/li>\n<li>\nProficient in basic reporting, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to work in active mining environments, including exposure to dust, noise, and varying weather conditions\n<\/li>\n<li>\nAbility to walk uneven terrain, climb equipment\/access points, and remain active throughout shift\n<\/li>\n<li>\nAbility to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to wear all required PPE on site<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/738a6ed3548a-mining-foreman-traveling","%breezy_id%":"738a6ed3548a","%breezy_friendly_id%":"738a6ed3548a-mining-foreman-traveling","%breezy_created_date%":"2026-04-10T18:22:28.145Z","%breezy_updated_date%":"2026-05-20T12:49:30.323Z","%_wpgmp_location_city%":"Tonopah","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tonopah, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.069211","%_wpgmp_metabox_longitude%":"-117.2305861","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"278"}},"id":3651,"infowindow_disable":false},{"source":"post","title":"General Laborer- Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Laborer- Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-laborer-mining\/\" name=\"General Laborer- Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations.&hellip;","address":"Tonopah, NV, USA","location":{"lat":"38.069211","city":"Tonopah","state":"NV","country":"United States","lng":"-117.2305861","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations.&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations. We are currently seeking motivated General Laborers to support a mining client in a dynamic production environment. This role is ideal for individuals who are safety-conscious, reliable, and eager to work in a hands-on mining setting.<\/p>\n<h3>Position Summary<\/h3>\n<p>The General Laborer is responsible for performing a variety of physical tasks that support daily mining site operations. This role assists equipment operators, maintenance personnel, and site supervisors with general site cleanup, material handling, equipment support, and other labor-intensive duties necessary to keep operations running safely and efficiently.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nPerform general physical labor duties in support of mining operations\n<\/li>\n<li>\nAssist with site cleanup, shoveling, sweeping, and debris removal around work areas\n<\/li>\n<li>\nSupport equipment operators and maintenance crews as needed\n<\/li>\n<li>\nLoad and unload materials, tools, and supplies\n<\/li>\n<li>\nMaintain safe, clean, and organized work areas\n<\/li>\n<li>\nFollow all mine site safety rules, procedures, and MSHA regulations\n<\/li>\n<li>\nIdentify and report unsafe conditions or equipment issues promptly\n<\/li>\n<li>\nUse hand tools and basic equipment safely and effectively\n<\/li>\n<li>\nComplete additional tasks assigned by supervisors to support production needs\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious labor experience in mining, construction, industrial, or outdoor environments preferred\n<\/li>\n<li>\nAbility to perform physically demanding work in rugged outdoor conditions\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong work ethic and willingness to learn\n<\/li>\n<li>\nAbility to follow instructions and work effectively as part of a team\n<\/li>\n<li>\nReliable transportation and dependable attendance required\n<\/li>\n<li>\nFlexibility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to lift, carry, push, and pull up to 50 pounds regularly\n<\/li>\n<li>\nAbility to stand, walk, bend, kneel, stoop, and climb for extended periods\n<\/li>\n<li>\nAbility to work outdoors in varying weather, dust, noise, and uneven terrain\n<\/li>\n<li>\nMust be able to wear required PPE at all times on site<\/li><\/ul>","post_title":"General Laborer- Mining","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Tonopah","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Tonopah, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations. We are currently seeking motivated General Laborers to support a mining client in a dynamic production environment. This role is ideal for individuals who are safety-conscious, reliable, and eager to work in a hands-on mining setting.<\/p>\n<h3>Position Summary<\/h3>\n<p>The General Laborer is responsible for performing a variety of physical tasks that support daily mining site operations. This role assists equipment operators, maintenance personnel, and site supervisors with general site cleanup, material handling, equipment support, and other labor-intensive duties necessary to keep operations running safely and efficiently.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nPerform general physical labor duties in support of mining operations\n<\/li>\n<li>\nAssist with site cleanup, shoveling, sweeping, and debris removal around work areas\n<\/li>\n<li>\nSupport equipment operators and maintenance crews as needed\n<\/li>\n<li>\nLoad and unload materials, tools, and supplies\n<\/li>\n<li>\nMaintain safe, clean, and organized work areas\n<\/li>\n<li>\nFollow all mine site safety rules, procedures, and MSHA regulations\n<\/li>\n<li>\nIdentify and report unsafe conditions or equipment issues promptly\n<\/li>\n<li>\nUse hand tools and basic equipment safely and effectively\n<\/li>\n<li>\nComplete additional tasks assigned by supervisors to support production needs\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious labor experience in mining, construction, industrial, or outdoor environments preferred\n<\/li>\n<li>\nAbility to perform physically demanding work in rugged outdoor conditions\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong work ethic and willingness to learn\n<\/li>\n<li>\nAbility to follow instructions and work effectively as part of a team\n<\/li>\n<li>\nReliable transportation and dependable attendance required\n<\/li>\n<li>\nFlexibility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to lift, carry, push, and pull up to 50 pounds regularly\n<\/li>\n<li>\nAbility to stand, walk, bend, kneel, stoop, and climb for extended periods\n<\/li>\n<li>\nAbility to work outdoors in varying weather, dust, noise, and uneven terrain\n<\/li>\n<li>\nMust be able to wear required PPE at all times on site<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/66894cb80b7d-general-laborer-mining","%breezy_id%":"66894cb80b7d","%breezy_friendly_id%":"66894cb80b7d-general-laborer-mining","%breezy_created_date%":"2026-04-10T18:08:50.995Z","%breezy_updated_date%":"2026-05-20T12:49:09.608Z","%_wpgmp_location_city%":"Tonopah","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tonopah, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.069211","%_wpgmp_metabox_longitude%":"-117.2305861","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"277"}},"id":3650,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-2\/\" name=\"Heavy Equipment Operator &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction,&hellip;","address":"Tonopah, NV, USA","location":{"lat":"38.069211","city":"Tonopah","state":"NV","country":"United States","lng":"-117.2305861","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-2\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction,&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction, and industrial sectors. We are currently seeking experienced Heavy Equipment Operators to support a mining client in a fast-paced production environment. This is an excellent opportunity for safety-focused individuals with mobile equipment experience who are looking to grow their careers in mining operations.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining operations. Equipment may include haul trucks, loaders, excavators, water trucks, dozers, graders, and other production support machinery. Operators play a critical role in maintaining production goals while adhering to strict safety and operational standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nOperate heavy mobile equipment in a safe, efficient, and productive manner\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections and complete required documentation\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions promptly\n<\/li>\n<li>\nFollow mine site safety procedures, policies, and MSHA regulations at all times\n<\/li>\n<li>\nWork closely with supervisors, dispatch, and other team members to meet daily production targets\n<\/li>\n<li>\nMaintain clean and orderly equipment cabs and work areas\n<\/li>\n<li>\nAssist with general mine site tasks as needed to support operations\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating heavy equipment in mining, quarry, construction, or similar industrial environments preferred\n<\/li>\n<li>\nAbility to safely operate one or more types of mobile equipment such as haul trucks, loaders, excavators, or dozers\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong understanding of equipment safety protocols and hazard awareness\n<\/li>\n<li>\nAbility to work in varying weather and site conditions\n<\/li>\n<li>\nReliable transportation and strong attendance record\n<\/li>\n<li>\nAbility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to sit, stand, climb, bend, and walk for extended periods\n<\/li>\n<li>\nAbility to climb in and out of heavy equipment multiple times per shift\n<\/li>\n<li>\nMust be able to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to work in dusty, rugged outdoor environments<\/li><\/ul>","post_title":"Heavy Equipment Operator &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Tonopah","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Tonopah, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction, and industrial sectors. We are currently seeking experienced Heavy Equipment Operators to support a mining client in a fast-paced production environment. This is an excellent opportunity for safety-focused individuals with mobile equipment experience who are looking to grow their careers in mining operations.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining operations. Equipment may include haul trucks, loaders, excavators, water trucks, dozers, graders, and other production support machinery. Operators play a critical role in maintaining production goals while adhering to strict safety and operational standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nOperate heavy mobile equipment in a safe, efficient, and productive manner\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections and complete required documentation\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions promptly\n<\/li>\n<li>\nFollow mine site safety procedures, policies, and MSHA regulations at all times\n<\/li>\n<li>\nWork closely with supervisors, dispatch, and other team members to meet daily production targets\n<\/li>\n<li>\nMaintain clean and orderly equipment cabs and work areas\n<\/li>\n<li>\nAssist with general mine site tasks as needed to support operations\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating heavy equipment in mining, quarry, construction, or similar industrial environments preferred\n<\/li>\n<li>\nAbility to safely operate one or more types of mobile equipment such as haul trucks, loaders, excavators, or dozers\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong understanding of equipment safety protocols and hazard awareness\n<\/li>\n<li>\nAbility to work in varying weather and site conditions\n<\/li>\n<li>\nReliable transportation and strong attendance record\n<\/li>\n<li>\nAbility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to sit, stand, climb, bend, and walk for extended periods\n<\/li>\n<li>\nAbility to climb in and out of heavy equipment multiple times per shift\n<\/li>\n<li>\nMust be able to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to work in dusty, rugged outdoor environments<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/01547c6ccca8-heavy-equipment-operator-traveling","%breezy_id%":"01547c6ccca8","%breezy_friendly_id%":"01547c6ccca8-heavy-equipment-operator-traveling","%breezy_created_date%":"2026-04-10T18:06:51.521Z","%breezy_updated_date%":"2026-05-20T12:49:05.710Z","%_wpgmp_location_city%":"Tonopah","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tonopah, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.069211","%_wpgmp_metabox_longitude%":"-117.2305861","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"276"}},"id":3649,"infowindow_disable":false},{"source":"post","title":"EHS Supervisor- Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    EHS Supervisor- Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are seeking an experienced and driven EHS Supervisor to support a mining client in the Midland, TX&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/ehs-supervisor-mining\/\" name=\"EHS Supervisor- Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are seeking an experienced and driven EHS Supervisor to support a mining client in the Midland, TX&hellip;","address":"Midland, TX, USA","location":{"lat":"31.9995797","city":"Midland","state":"TX","country":"United States","lng":"-102.0756701","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/ehs-supervisor-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are seeking an experienced and driven EHS Supervisor to support a mining client in the Midland, TX&hellip;","post_content":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking an experienced and driven <strong>EHS Supervisor<\/strong> to support a mining client in the Midland, TX area. This position plays a critical leadership role in developing, implementing, and maintaining environmental, health, and safety (EHS) programs across active mining operations.<\/p>\n<p>Working closely with site leadership and corporate EHS teams, the EHS Supervisor will ensure compliance with all applicable federal, state, and client-specific regulations while fostering a proactive safety culture. This individual will spend significant time in the field, partnering with operations personnel to identify risks, implement solutions, and drive continuous improvement in safety and environmental performance.<\/p>\n<p>The ideal candidate is a hands-on leader who is proactive, highly organized, and capable of influencing employees at all levels of the organization.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<p><strong>Safety Program Leadership &amp; Compliance<\/strong><\/p>\n<ul>\n<li>\n<p>Implement, administer, and enforce site-wide safety, health, and environmental programs<\/p>\n<\/li>\n<li>\n<p>Ensure compliance with all <strong>MSHA<\/strong>, state, federal, and client-specific regulations<\/p>\n<\/li>\n<li>\n<p>Prepare and submit required regulatory reports, including MSHA documentation<\/p>\n<\/li>\n<li>\n<p>Maintain compliance with all permits and environmental requirements<\/p>\n<\/li>\n<\/ul>\n<p><strong>Training &amp; Development<\/strong><\/p>\n<ul>\n<li>\n<p>Lead and manage site safety training programs, including new hire onboarding and annual refresher training<\/p>\n<\/li>\n<li>\n<p>Promote workforce engagement and awareness of EHS policies and best practices<\/p>\n<\/li>\n<li>\n<p>Provide coaching and guidance to supervisors and employees on safety-related matters<\/p>\n<\/li>\n<\/ul>\n<p><strong>Field Presence &amp; Risk Management<\/strong><\/p>\n<ul>\n<li>\n<p>Maintain a strong field presence (approximately 60% of time) to monitor operations and proactively address safety concerns<\/p>\n<\/li>\n<li>\n<p>Conduct inspections, audits, and observations to identify hazards and ensure corrective actions are implemented<\/p>\n<\/li>\n<li>\n<p>Build strong working relationships with field personnel and site leadership<\/p>\n<\/li>\n<\/ul>\n<p><strong>Incident Management &amp; Reporting<\/strong><\/p>\n<ul>\n<li>\n<p>Lead incident investigations, root cause analysis, and corrective action development<\/p>\n<\/li>\n<li>\n<p>Document and track incidents using client-required systems (e.g., IndustrySafe or similar platforms)<\/p>\n<\/li>\n<li>\n<p>Support industrial hygiene sampling and monitoring as needed<\/p>\n<\/li>\n<\/ul>\n<p><strong>Collaboration &amp; Leadership<\/strong><\/p>\n<ul>\n<li>\n<p>Partner with operations, maintenance, and leadership teams to drive continuous improvement in EHS performance<\/p>\n<\/li>\n<li>\n<p>Lead or support site EHS committees and initiatives<\/p>\n<\/li>\n<li>\n<p>Serve as a key resource during emergency response situations<\/p>\n<\/li>\n<\/ul>\n<p><strong>Additional Responsibilities<\/strong><\/p>\n<ul>\n<li>\n<p>Maintain accurate and organized training and compliance records<\/p>\n<\/li>\n<li>\n<p>Ensure contractor compliance with client safety standards<\/p>\n<\/li>\n<li>\n<p>Stay current on EHS regulations and industry best practices through ongoing professional development<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Schedule<\/strong><\/h3>\n<ul>\n<li>\n<p>Primarily field-based role within an active mining operation<\/p>\n<\/li>\n<li>\n<p>Approximately 60% of time spent in the field<\/p>\n<\/li>\n<li>\n<p>Flexible schedule required, with ability to respond to emergencies as needed<\/p>\n<\/li>\n<li>\n<p>Some travel may be required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<p><strong>Education<\/strong><\/p>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Safety, Environmental Science, Occupational Health, or related field preferred<\/p>\n<\/li>\n<li>\n<p>Equivalent combination of education and relevant experience will be considered<\/p>\n<\/li>\n<\/ul>\n<p><strong>Required Experience &amp; Skills<\/strong><\/p>\n<ul>\n<li>\n<p>Experience in EHS within mining, construction, or heavy industrial environments<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of <strong>MSHA regulations, standards, and inspection processes<\/strong><\/p>\n<\/li>\n<li>\n<p>Proven ability to lead safety programs and influence a positive safety culture<\/p>\n<\/li>\n<li>\n<p>Excellent organizational and project management skills<\/p>\n<\/li>\n<li>\n<p>Strong verbal and written communication skills across all levels of an organization<\/p>\n<\/li>\n<li>\n<p>Ability to analyze problems, identify root causes, and implement effective solutions<\/p>\n<\/li>\n<li>\n<p>Ability to work independently with minimal supervision<\/p>\n<\/li>\n<\/ul>\n<p><strong>Preferred Qualifications<\/strong><\/p>\n<ul>\n<li>\n<p>Prior experience in mining operations<\/p>\n<\/li>\n<li>\n<p>Experience with environmental permitting and regulatory compliance<\/p>\n<\/li>\n<li>\n<p>Familiarity with incident management systems (e.g., IndustrySafe)<\/p>\n<\/li>\n<li>\n<p>Industrial hygiene sampling experience<\/p>\n<\/li>\n<li>\n<p>Operational or field leadership background<\/p><\/li><\/ul>","post_title":"EHS Supervisor- Mining","post_link":"https:\/\/turnerstaffing.com\/position\/ehs-supervisor-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Midland","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Midland, TX","%education%":"Bachelor's Degree","%department%":"TSG","%description%":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking an experienced and driven <strong>EHS Supervisor<\/strong> to support a mining client in the Midland, TX area. This position plays a critical leadership role in developing, implementing, and maintaining environmental, health, and safety (EHS) programs across active mining operations.<\/p>\n<p>Working closely with site leadership and corporate EHS teams, the EHS Supervisor will ensure compliance with all applicable federal, state, and client-specific regulations while fostering a proactive safety culture. This individual will spend significant time in the field, partnering with operations personnel to identify risks, implement solutions, and drive continuous improvement in safety and environmental performance.<\/p>\n<p>The ideal candidate is a hands-on leader who is proactive, highly organized, and capable of influencing employees at all levels of the organization.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<p><strong>Safety Program Leadership &amp; Compliance<\/strong><\/p>\n<ul>\n<li>\n<p>Implement, administer, and enforce site-wide safety, health, and environmental programs<\/p>\n<\/li>\n<li>\n<p>Ensure compliance with all <strong>MSHA<\/strong>, state, federal, and client-specific regulations<\/p>\n<\/li>\n<li>\n<p>Prepare and submit required regulatory reports, including MSHA documentation<\/p>\n<\/li>\n<li>\n<p>Maintain compliance with all permits and environmental requirements<\/p>\n<\/li>\n<\/ul>\n<p><strong>Training &amp; Development<\/strong><\/p>\n<ul>\n<li>\n<p>Lead and manage site safety training programs, including new hire onboarding and annual refresher training<\/p>\n<\/li>\n<li>\n<p>Promote workforce engagement and awareness of EHS policies and best practices<\/p>\n<\/li>\n<li>\n<p>Provide coaching and guidance to supervisors and employees on safety-related matters<\/p>\n<\/li>\n<\/ul>\n<p><strong>Field Presence &amp; Risk Management<\/strong><\/p>\n<ul>\n<li>\n<p>Maintain a strong field presence (approximately 60% of time) to monitor operations and proactively address safety concerns<\/p>\n<\/li>\n<li>\n<p>Conduct inspections, audits, and observations to identify hazards and ensure corrective actions are implemented<\/p>\n<\/li>\n<li>\n<p>Build strong working relationships with field personnel and site leadership<\/p>\n<\/li>\n<\/ul>\n<p><strong>Incident Management &amp; Reporting<\/strong><\/p>\n<ul>\n<li>\n<p>Lead incident investigations, root cause analysis, and corrective action development<\/p>\n<\/li>\n<li>\n<p>Document and track incidents using client-required systems (e.g., IndustrySafe or similar platforms)<\/p>\n<\/li>\n<li>\n<p>Support industrial hygiene sampling and monitoring as needed<\/p>\n<\/li>\n<\/ul>\n<p><strong>Collaboration &amp; Leadership<\/strong><\/p>\n<ul>\n<li>\n<p>Partner with operations, maintenance, and leadership teams to drive continuous improvement in EHS performance<\/p>\n<\/li>\n<li>\n<p>Lead or support site EHS committees and initiatives<\/p>\n<\/li>\n<li>\n<p>Serve as a key resource during emergency response situations<\/p>\n<\/li>\n<\/ul>\n<p><strong>Additional Responsibilities<\/strong><\/p>\n<ul>\n<li>\n<p>Maintain accurate and organized training and compliance records<\/p>\n<\/li>\n<li>\n<p>Ensure contractor compliance with client safety standards<\/p>\n<\/li>\n<li>\n<p>Stay current on EHS regulations and industry best practices through ongoing professional development<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Schedule<\/strong><\/h3>\n<ul>\n<li>\n<p>Primarily field-based role within an active mining operation<\/p>\n<\/li>\n<li>\n<p>Approximately 60% of time spent in the field<\/p>\n<\/li>\n<li>\n<p>Flexible schedule required, with ability to respond to emergencies as needed<\/p>\n<\/li>\n<li>\n<p>Some travel may be required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<p><strong>Education<\/strong><\/p>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Safety, Environmental Science, Occupational Health, or related field preferred<\/p>\n<\/li>\n<li>\n<p>Equivalent combination of education and relevant experience will be considered<\/p>\n<\/li>\n<\/ul>\n<p><strong>Required Experience &amp; Skills<\/strong><\/p>\n<ul>\n<li>\n<p>Experience in EHS within mining, construction, or heavy industrial environments<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of <strong>MSHA regulations, standards, and inspection processes<\/strong><\/p>\n<\/li>\n<li>\n<p>Proven ability to lead safety programs and influence a positive safety culture<\/p>\n<\/li>\n<li>\n<p>Excellent organizational and project management skills<\/p>\n<\/li>\n<li>\n<p>Strong verbal and written communication skills across all levels of an organization<\/p>\n<\/li>\n<li>\n<p>Ability to analyze problems, identify root causes, and implement effective solutions<\/p>\n<\/li>\n<li>\n<p>Ability to work independently with minimal supervision<\/p>\n<\/li>\n<\/ul>\n<p><strong>Preferred Qualifications<\/strong><\/p>\n<ul>\n<li>\n<p>Prior experience in mining operations<\/p>\n<\/li>\n<li>\n<p>Experience with environmental permitting and regulatory compliance<\/p>\n<\/li>\n<li>\n<p>Familiarity with incident management systems (e.g., IndustrySafe)<\/p>\n<\/li>\n<li>\n<p>Industrial hygiene sampling experience<\/p>\n<\/li>\n<li>\n<p>Operational or field leadership background<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a595775bb4dc-ehs-supervisor-mining","%breezy_id%":"a595775bb4dc","%breezy_friendly_id%":"a595775bb4dc-ehs-supervisor-mining","%breezy_created_date%":"2026-03-24T12:26:31.562Z","%breezy_updated_date%":"2026-05-19T16:12:19.670Z","%_wpgmp_location_city%":"Midland","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Midland, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9995797","%_wpgmp_metabox_longitude%":"-102.0756701","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"274"}},"id":3648,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Mobile Equipment Mechanic \u2013 Mining Equipment Fleet Job Summary We are seeking an experienced Mobile Equipment Mechanic to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Mobile Equipment Mechanic \u2013 Mining Equipment Fleet Job Summary We are seeking an experienced Mobile Equipment Mechanic to&hellip;","address":"Bullhead City, AZ, USA","location":{"lat":"35.1359386","city":"Bullhead City","state":"AZ","country":"United States","lng":"-114.5285981","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Mobile Equipment Mechanic \u2013 Mining Equipment Fleet Job Summary We are seeking an experienced Mobile Equipment Mechanic to&hellip;","post_content":"<h2><strong>Job Title: Mobile Equipment Mechanic \u2013 Mining Equipment Fleet<\/strong><\/h2>\n<h3><strong>Job Summary<\/strong><\/h3>\n<p>We are seeking an experienced <strong>Mobile Equipment Mechanic<\/strong> to support daily mining operations by maintaining and repairing a fleet of heavy mobile equipment. This role is critical to keeping production running by minimizing downtime and ensuring all equipment is operating safely and efficiently.<\/p>\n<p>The mechanic will primarily work on large mining equipment including but not limited too -&nbsp;CAT 777 haul trucks, CAT 993K\/992 loaders, DM45 Drills,&nbsp;and CAT D9 dozers in both field and shop environments.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform repairs and preventative maintenance on mining equipment&nbsp;including but not limited too:<\/p>\n<ul>\n<li>\n<p>CAT 777 Haul Trucks<\/p>\n<\/li>\n<li>\n<p>CAT 993K &amp; CAT 992 Loaders<\/p>\n<\/li>\n<li>\n<p>CAT D9 Dozers<\/p>\n<\/li><li><p>DM 45 Drills&nbsp;<\/p><\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Diagnose and troubleshoot mechanical, hydraulic, and electrical failures in a fast-paced production environment<\/p>\n<\/li>\n<li>\n<p>Respond to field breakdowns and perform on-site repairs to reduce downtime<\/p>\n<\/li>\n<li>\n<p>Complete scheduled maintenance services (PMs), inspections, and component replacements<\/p>\n<\/li>\n<li>\n<p>Work with maintenance planners and operations teams to prioritize repairs based on production needs<\/p>\n<\/li>\n<li>\n<p>Utilize diagnostic software (CAT ET preferred) and service manuals to identify issues<\/p>\n<\/li>\n<li>\n<p>Maintain accurate maintenance records, work orders, and inspection reports<\/p>\n<\/li>\n<li>\n<p>Perform basic welding and fabrication as needed<\/p>\n<\/li>\n<li>\n<p>Ensure all work is performed in compliance with <strong>MSHA regulations and site safety standards<\/strong><\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, inspections, and audits<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>3+ years of experience as a heavy equipment or mining equipment mechanic<\/p>\n<\/li>\n<li>\n<p>Strong experience working on large CAT mining equipment (777 haul trucks, 992\/993 loaders, D9 dozers preferred)<\/p>\n<\/li>\n<li>\n<p>Solid understanding of diesel engines, hydraulics, electrical systems, and powertrain components<\/p>\n<\/li>\n<li>\n<p>Experience diagnosing and repairing equipment in a mining or high-production environment<\/p>\n<\/li>\n<li>\n<p>Ability to read schematics, blueprints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Experience with CAT ET or similar diagnostic tools preferred<\/p>\n<\/li>\n<li>\n<p>Welding and fabrication experience is a plus<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required (CDL preferred)<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Schedule<\/strong><\/h3>\n<ul>\n<li>\n<p>Work performed in an <strong>active mine site<\/strong> (surface mining operation)<\/p>\n<\/li>\n<li>\n<p>Combination of shop work and field service in varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Exposure to dust, noise, vibration, and heavy equipment traffic<\/p>\n<\/li>\n<li>\n<p>Schedule:<\/p>\n<ul>\n<li>\n<p>7 day on 7 day off&nbsp;<\/p>\n<\/li><li><p>12 hours&nbsp;<\/p><\/li><li><p>Day Shift&nbsp;<\/p><\/li><\/ul><\/li>\n<\/ul>\n<h3><strong>Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\n<p>Ability to lift 50+ lbs regularly<\/p>\n<\/li>\n<li>\n<p>Climb ladders, access large equipment, and work at heights<\/p>\n<\/li>\n<li>\n<p>Frequent bending, kneeling, and working in confined spaces<\/p>\n<\/li>\n<li>\n<p>Ability to stand for extended periods and work in physically demanding conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\n<p>Mechanic who thrives in a <strong>production-driven mining environment<\/strong><\/p>\n<\/li>\n<li>\n<p>Strong diagnostic and troubleshooting ability under pressure<\/p>\n<\/li>\n<li>\n<p>Safety-first mindset with strong awareness of MSHA standards<\/p>\n<\/li>\n<li>\n<p>Self-starter who can work independently in the field<\/p>\n<\/li>\n<li>\n<p>Team player who communicates well with operators and supervisors<\/p><\/li><\/ul>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Bullhead City","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bullhead City, AZ","%education%":"","%department%":"TSG","%description%":"<h2><strong>Job Title: Mobile Equipment Mechanic \u2013 Mining Equipment Fleet<\/strong><\/h2>\n<h3><strong>Job Summary<\/strong><\/h3>\n<p>We are seeking an experienced <strong>Mobile Equipment Mechanic<\/strong> to support daily mining operations by maintaining and repairing a fleet of heavy mobile equipment. This role is critical to keeping production running by minimizing downtime and ensuring all equipment is operating safely and efficiently.<\/p>\n<p>The mechanic will primarily work on large mining equipment including but not limited too -&nbsp;CAT 777 haul trucks, CAT 993K\/992 loaders, DM45 Drills,&nbsp;and CAT D9 dozers in both field and shop environments.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform repairs and preventative maintenance on mining equipment&nbsp;including but not limited too:<\/p>\n<ul>\n<li>\n<p>CAT 777 Haul Trucks<\/p>\n<\/li>\n<li>\n<p>CAT 993K &amp; CAT 992 Loaders<\/p>\n<\/li>\n<li>\n<p>CAT D9 Dozers<\/p>\n<\/li><li><p>DM 45 Drills&nbsp;<\/p><\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Diagnose and troubleshoot mechanical, hydraulic, and electrical failures in a fast-paced production environment<\/p>\n<\/li>\n<li>\n<p>Respond to field breakdowns and perform on-site repairs to reduce downtime<\/p>\n<\/li>\n<li>\n<p>Complete scheduled maintenance services (PMs), inspections, and component replacements<\/p>\n<\/li>\n<li>\n<p>Work with maintenance planners and operations teams to prioritize repairs based on production needs<\/p>\n<\/li>\n<li>\n<p>Utilize diagnostic software (CAT ET preferred) and service manuals to identify issues<\/p>\n<\/li>\n<li>\n<p>Maintain accurate maintenance records, work orders, and inspection reports<\/p>\n<\/li>\n<li>\n<p>Perform basic welding and fabrication as needed<\/p>\n<\/li>\n<li>\n<p>Ensure all work is performed in compliance with <strong>MSHA regulations and site safety standards<\/strong><\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, inspections, and audits<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>3+ years of experience as a heavy equipment or mining equipment mechanic<\/p>\n<\/li>\n<li>\n<p>Strong experience working on large CAT mining equipment (777 haul trucks, 992\/993 loaders, D9 dozers preferred)<\/p>\n<\/li>\n<li>\n<p>Solid understanding of diesel engines, hydraulics, electrical systems, and powertrain components<\/p>\n<\/li>\n<li>\n<p>Experience diagnosing and repairing equipment in a mining or high-production environment<\/p>\n<\/li>\n<li>\n<p>Ability to read schematics, blueprints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Experience with CAT ET or similar diagnostic tools preferred<\/p>\n<\/li>\n<li>\n<p>Welding and fabrication experience is a plus<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required (CDL preferred)<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Schedule<\/strong><\/h3>\n<ul>\n<li>\n<p>Work performed in an <strong>active mine site<\/strong> (surface mining operation)<\/p>\n<\/li>\n<li>\n<p>Combination of shop work and field service in varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Exposure to dust, noise, vibration, and heavy equipment traffic<\/p>\n<\/li>\n<li>\n<p>Schedule:<\/p>\n<ul>\n<li>\n<p>7 day on 7 day off&nbsp;<\/p>\n<\/li><li><p>12 hours&nbsp;<\/p><\/li><li><p>Day Shift&nbsp;<\/p><\/li><\/ul><\/li>\n<\/ul>\n<h3><strong>Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\n<p>Ability to lift 50+ lbs regularly<\/p>\n<\/li>\n<li>\n<p>Climb ladders, access large equipment, and work at heights<\/p>\n<\/li>\n<li>\n<p>Frequent bending, kneeling, and working in confined spaces<\/p>\n<\/li>\n<li>\n<p>Ability to stand for extended periods and work in physically demanding conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<ul>\n<li>\n<p>Mechanic who thrives in a <strong>production-driven mining environment<\/strong><\/p>\n<\/li>\n<li>\n<p>Strong diagnostic and troubleshooting ability under pressure<\/p>\n<\/li>\n<li>\n<p>Safety-first mindset with strong awareness of MSHA standards<\/p>\n<\/li>\n<li>\n<p>Self-starter who can work independently in the field<\/p>\n<\/li>\n<li>\n<p>Team player who communicates well with operators and supervisors<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/721fca46aed9-heavy-equipment-mechanic","%breezy_id%":"721fca46aed9","%breezy_friendly_id%":"721fca46aed9-heavy-equipment-mechanic","%breezy_created_date%":"2026-03-19T20:00:47.238Z","%breezy_updated_date%":"2026-05-19T18:02:38.019Z","%_wpgmp_location_city%":"Bullhead City","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bullhead City, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1359386","%_wpgmp_metabox_longitude%":"-114.5285981","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"273"}},"id":3647,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Haul Truck Driver You You want to work for a services company that is rapidly changing&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-3\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver You You want to work for a services company that is rapidly changing&hellip;","address":"Lovelock, NV, USA","location":{"lat":"40.1793537","city":"Lovelock","state":"NV","country":"United States","lng":"-118.4734808","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Haul Truck Driver You You want to work for a services company that is rapidly changing&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><br><\/p>\n\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Lovelock","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Lovelock, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><br><\/p>\n\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a2dc90e7ee34-haul-truck-driver","%breezy_id%":"a2dc90e7ee34","%breezy_friendly_id%":"a2dc90e7ee34-haul-truck-driver","%breezy_created_date%":"2025-08-05T16:00:58.384Z","%breezy_updated_date%":"2026-05-19T18:00:55.679Z","%_wpgmp_location_city%":"Lovelock","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lovelock, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1793537","%_wpgmp_metabox_longitude%":"-118.4734808","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"272"}},"id":3646,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-2\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Linton, IN, USA","location":{"lat":"39.0347666","city":"Linton","state":"IN","country":"United States","lng":"-87.1658458","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <\/p>\n<p>Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity in Linton, IN.<\/p>\n<p>Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Staffing Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><br><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Linton","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Linton, IN","%education%":"Unspecified","%department%":"TSG","%description%":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <\/p>\n<p>Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity in Linton, IN.<\/p>\n<p>Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Staffing Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><br><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/17eabb7c25e4-haul-truck-driver","%breezy_id%":"17eabb7c25e4","%breezy_friendly_id%":"17eabb7c25e4-haul-truck-driver","%breezy_created_date%":"2025-05-29T13:50:01.472Z","%breezy_updated_date%":"2026-05-19T18:06:42.879Z","%_wpgmp_location_city%":"Linton","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Linton, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.0347666","%_wpgmp_metabox_longitude%":"-87.1658458","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"271"}},"id":3645,"infowindow_disable":false},{"source":"post","title":"993K Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    993K Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a highly skilled and experienced Loader Operator to operate a Caterpillar 993K Loader at a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/993k-loader-operator\/\" name=\"993K Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a highly skilled and experienced Loader Operator to operate a Caterpillar 993K Loader at a&hellip;","address":"Bullhead City, AZ, USA","location":{"lat":"35.1359386","city":"Bullhead City","state":"AZ","country":"United States","lng":"-114.5285981","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/993k-loader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a highly skilled and experienced Loader Operator to operate a Caterpillar 993K Loader at a&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Loader Operator<\/strong> to operate a <strong>Caterpillar 993K Loader<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in large loaders in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a CAT 993K Loader in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Load haul trucks and maintain adequate feed to the crusher<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p>\n<\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating large loaders (preferably CAT 993K or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","post_title":"993K Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/993k-loader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bullhead City","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bullhead City, AZ","%education%":"Unspecified","%department%":"TSG","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Loader Operator<\/strong> to operate a <strong>Caterpillar 993K Loader<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in large loaders in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a CAT 993K Loader in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Load haul trucks and maintain adequate feed to the crusher<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p>\n<\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating large loaders (preferably CAT 993K or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/739db71f4057-993k-loader-operator","%breezy_id%":"739db71f4057","%breezy_friendly_id%":"739db71f4057-993k-loader-operator","%breezy_created_date%":"2025-05-21T18:47:48.115Z","%breezy_updated_date%":"2026-05-19T18:02:56.649Z","%_wpgmp_location_city%":"Bullhead City","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bullhead City, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1359386","%_wpgmp_metabox_longitude%":"-114.5285981","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"269"}},"id":3643,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Carlisle, IN, USA","location":{"lat":"38.9623034","city":"Carlisle","state":"IN","country":"United States","lng":"-87.4025572","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <\/p>\n<p>Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity in Carlisle, IN.<\/p>\n<p>Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Staffing Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><br><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Carlisle","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Carlisle, IN","%education%":"Unspecified","%department%":"TSG","%description%":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <\/p>\n<p>Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity in Carlisle, IN.<\/p>\n<p>Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Staffing Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><br><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/f965badf42cf-haul-truck-driver","%breezy_id%":"f965badf42cf","%breezy_friendly_id%":"f965badf42cf-haul-truck-driver","%breezy_created_date%":"2025-05-23T17:11:35.282Z","%breezy_updated_date%":"2026-05-19T18:01:49.024Z","%_wpgmp_location_city%":"Carlisle","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Carlisle, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9623034","%_wpgmp_metabox_longitude%":"-87.4025572","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"270"}},"id":3644,"infowindow_disable":false},{"source":"post","title":"HR Director","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    HR Director\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are seeking an experienced and strategic Human Resources Director to lead and manage all aspects of human&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/hr-director\/\" name=\"HR Director\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are seeking an experienced and strategic Human Resources Director to lead and manage all aspects of human&hellip;","address":"San Antonio, TX, USA","location":{"lat":"29.4251905","city":"San Antonio","state":"TX","country":"United States","lng":"-98.4945922","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/hr-director\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are seeking an experienced and strategic Human Resources Director to lead and manage all aspects of human&hellip;","post_content":"<h3>Position Overview<\/h3>\n<p>We are seeking an experienced and strategic <strong>Human Resources Director<\/strong> to lead and manage all aspects of human resources for our growing contract mining organization. This role will be based in our customer's San Antonio&nbsp;home office and will serve as a key member of the leadership team, supporting both field operations and corporate functions across multiple project sites.<\/p>\n<p>The Human Resources Director will be responsible for developing and executing HR strategies that align with business objectives, ensure compliance, strengthen workforce development, and promote a strong safety- and performance-driven culture.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Lead and oversee all HR functions, including recruitment, onboarding, employee relations, performance management, compensation, benefits, and training<\/p>\n<\/li>\n<li>\n<p>Partner with executive leadership to develop and implement HR strategies that support company growth and operational needs<\/p>\n<\/li>\n<li>\n<p>Ensure compliance with all federal, state, and local employment laws and regulations, including those relevant to mining and construction environments<\/p>\n<\/li>\n<li>\n<p>Manage talent acquisition efforts for both salaried and hourly roles across corporate and field operations<\/p>\n<\/li>\n<li>\n<p>Develop and maintain HR policies, procedures, and employee handbook updates<\/p>\n<\/li>\n<li>\n<p>Provide guidance and support to managers on employee relations matters, disciplinary actions, and performance issues<\/p>\n<\/li>\n<li>\n<p>Oversee benefits administration, payroll coordination, and HRIS systems<\/p>\n<\/li>\n<li>\n<p>Lead workforce planning, succession planning, and employee development initiatives<\/p>\n<\/li>\n<li>\n<p>Support safety culture initiatives in coordination with operations and safety leadership<\/p>\n<\/li>\n<li>\n<p>Analyze HR metrics and trends to support data-driven decision-making<\/p>\n<\/li>\n<li>\n<p>Manage and mentor HR staff as the department grows<\/p>\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Human Resources, Business Administration, or a related field (Master\u2019s degree preferred)<\/p>\n<\/li>\n<li>\n<p>8+ years of progressive HR experience, with at least 3\u20135 years in a leadership or director-level role<\/p>\n<\/li>\n<li>\n<p>Experience in telecom, mining, construction, heavy civil, or industrial environments strongly preferred<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of employment law, compliance, and best HR practices<\/p>\n<\/li>\n<li>\n<p>Proven ability to work effectively with field-based and corporate teams<\/p>\n<\/li>\n<li>\n<p>Excellent leadership, communication, and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Experience supporting multi-state or multi-site operations preferred<\/p>\n<\/li>\n<li>\n<p>SHRM-SCP, SPHR, or similar professional certification a plus<\/p>\n<\/li>\n<\/ul>\n<h3>What We Offer<\/h3>\n<ul>\n<li>\n<p>Competitive salary and benefits package<\/p>\n<\/li>\n<li>\n<p>Opportunity to play a key leadership role in a growing, dynamic mining services company<\/p>\n<\/li>\n<li>\n<p>Collaborative, team-oriented work environment<\/p>\n<\/li>\n<li>\n<p>Long-term career growth and professional development opportunities<\/p><\/li><\/ul>","post_title":"HR Director","post_link":"https:\/\/turnerstaffing.com\/position\/hr-director\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"San Antonio","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"San Antonio, TX","%education%":"Bachelor's Degree","%department%":"TSG","%description%":"<h3>Position Overview<\/h3>\n<p>We are seeking an experienced and strategic <strong>Human Resources Director<\/strong> to lead and manage all aspects of human resources for our growing contract mining organization. This role will be based in our customer's San Antonio&nbsp;home office and will serve as a key member of the leadership team, supporting both field operations and corporate functions across multiple project sites.<\/p>\n<p>The Human Resources Director will be responsible for developing and executing HR strategies that align with business objectives, ensure compliance, strengthen workforce development, and promote a strong safety- and performance-driven culture.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Lead and oversee all HR functions, including recruitment, onboarding, employee relations, performance management, compensation, benefits, and training<\/p>\n<\/li>\n<li>\n<p>Partner with executive leadership to develop and implement HR strategies that support company growth and operational needs<\/p>\n<\/li>\n<li>\n<p>Ensure compliance with all federal, state, and local employment laws and regulations, including those relevant to mining and construction environments<\/p>\n<\/li>\n<li>\n<p>Manage talent acquisition efforts for both salaried and hourly roles across corporate and field operations<\/p>\n<\/li>\n<li>\n<p>Develop and maintain HR policies, procedures, and employee handbook updates<\/p>\n<\/li>\n<li>\n<p>Provide guidance and support to managers on employee relations matters, disciplinary actions, and performance issues<\/p>\n<\/li>\n<li>\n<p>Oversee benefits administration, payroll coordination, and HRIS systems<\/p>\n<\/li>\n<li>\n<p>Lead workforce planning, succession planning, and employee development initiatives<\/p>\n<\/li>\n<li>\n<p>Support safety culture initiatives in coordination with operations and safety leadership<\/p>\n<\/li>\n<li>\n<p>Analyze HR metrics and trends to support data-driven decision-making<\/p>\n<\/li>\n<li>\n<p>Manage and mentor HR staff as the department grows<\/p>\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Human Resources, Business Administration, or a related field (Master\u2019s degree preferred)<\/p>\n<\/li>\n<li>\n<p>8+ years of progressive HR experience, with at least 3\u20135 years in a leadership or director-level role<\/p>\n<\/li>\n<li>\n<p>Experience in telecom, mining, construction, heavy civil, or industrial environments strongly preferred<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of employment law, compliance, and best HR practices<\/p>\n<\/li>\n<li>\n<p>Proven ability to work effectively with field-based and corporate teams<\/p>\n<\/li>\n<li>\n<p>Excellent leadership, communication, and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Experience supporting multi-state or multi-site operations preferred<\/p>\n<\/li>\n<li>\n<p>SHRM-SCP, SPHR, or similar professional certification a plus<\/p>\n<\/li>\n<\/ul>\n<h3>What We Offer<\/h3>\n<ul>\n<li>\n<p>Competitive salary and benefits package<\/p>\n<\/li>\n<li>\n<p>Opportunity to play a key leadership role in a growing, dynamic mining services company<\/p>\n<\/li>\n<li>\n<p>Collaborative, team-oriented work environment<\/p>\n<\/li>\n<li>\n<p>Long-term career growth and professional development opportunities<\/p><\/li><\/ul>","%category%":"Human Resources","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/f260434b2848-hr-director","%breezy_id%":"f260434b2848","%breezy_friendly_id%":"f260434b2848-hr-director","%breezy_created_date%":"2026-05-19T12:42:27.692Z","%breezy_updated_date%":"2026-05-19T12:42:51.559Z","%_wpgmp_location_city%":"San Antonio","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"San Antonio, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.4251905","%_wpgmp_metabox_longitude%":"-98.4945922","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"267"}},"id":3642,"infowindow_disable":false},{"source":"post","title":"Line\/Utility Attachment Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Line\/Utility Attachment Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position SummaryThe Utility\/Joint Use Attachment Engineer is responsible for reviewing, designing, and approving pole attachment applications for communications and utility&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/joint-use-attachment-engineer\/\" name=\"Line\/Utility Attachment Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position SummaryThe Utility\/Joint Use Attachment Engineer is responsible for reviewing, designing, and approving pole attachment applications for communications and utility&hellip;","address":"San Antonio, TX, USA","location":{"lat":"29.4251905","city":"San Antonio","state":"TX","country":"United States","lng":"-98.4945922","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/joint-use-attachment-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Position SummaryThe Utility\/Joint Use Attachment Engineer is responsible for reviewing, designing, and approving pole attachment applications for communications and utility&hellip;","post_content":"<p><strong>Position Summary<\/strong><br>The Utility\/Joint Use Attachment Engineer is responsible for reviewing, designing, and approving pole attachment applications for communications and utility infrastructure. This role ensures compliance with engineering standards, safety regulations, and applicable codes (such as the NESC), while maintaining the integrity and reliability of the electric distribution system. The engineer collaborates with internal teams, telecom providers, and regulatory bodies to facilitate safe and efficient joint use of utility poles.<br><strong><br><\/strong><\/p>\n<p><strong>Key Responsibilities<\/strong><br>    \u2022    Review joint use applications for pole attachments, including telecom, fiber, cable, and wireless equipment installations.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Perform structural and load analysis of utility poles to ensure compliance with design and safety standards.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Evaluate pole capacity and determine make-ready requirements necessary to accommodate new attachments.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Design and specify required upgrades, such as pole replacements, guying, or rearrangements.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Ensure adherence to National Electrical Safety Code (NESC), company standards, and local\/state regulations.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Coordinate with internal departments (engineering, construction, operations) and third-party attachers.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Provide cost estimates and contribute to project timelines for make-ready work.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Review and approve engineering drawings, construction plans, and field data.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Resolve field issues related to pole attachments, including conflicts or clearance violations.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Support field inspections or audits of existing pole conditions and attachments.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Maintain accurate engineering and asset records in GIS or work management systems.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Assist in developing and improving joint use policies, standards, and processes.<br><strong><br><\/strong><\/p>\n<p><strong>Required Qualifications<\/strong><br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Bachelor\u2019s degree in Electrical Engineering, Civil Engineering, or a related field (or equivalent experience).<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;2\u20135+ years of experience in utility distribution engineering, telecommunications, or joint use engineering.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Knowledge of overhead distribution systems and pole line construction practices.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Familiarity with NESC, OSHA regulations, and joint use agreements.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Experience with pole loading analysis software (e.g., O-Calc, SpidaCalc, Katapult, or similar).<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Strong analytical and problem-solving skills.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Ability to interpret engineering drawings and technical specifications.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Excellent communication and coordination skills.<br><strong><br><\/strong><\/p>\n<p><strong>Preferred Qualifications<\/strong><br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Professional Engineer (PE) license or progress toward licensure.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Experience working with electric utilities or telecom providers.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Familiarity with GIS systems and utility asset management databases.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Knowledge of make-ready engineering and FCC pole attachment rules.<br><strong><br><\/strong><\/p>\n<p><strong>Key Competencies<\/strong><br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Attention to detail and safety awareness<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Technical and structural analysis expertise<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Project coordination and stakeholder management<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Regulatory compliance understanding<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Time management and ability to handle multiple projects<br><strong><br><\/strong><\/p>\n<p><strong>Work Environment<\/strong><br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Primarily office-based with occasional field visits.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;May require site inspections in varying weather and terrain conditions.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Interaction with customers, contractors, and regulatory agencies.<\/p>","post_title":"Line\/Utility Attachment Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/joint-use-attachment-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"San Antonio","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"San Antonio, TX","%education%":"Bachelor's Degree","%department%":"TSG","%description%":"<p><strong>Position Summary<\/strong><br>The Utility\/Joint Use Attachment Engineer is responsible for reviewing, designing, and approving pole attachment applications for communications and utility infrastructure. This role ensures compliance with engineering standards, safety regulations, and applicable codes (such as the NESC), while maintaining the integrity and reliability of the electric distribution system. The engineer collaborates with internal teams, telecom providers, and regulatory bodies to facilitate safe and efficient joint use of utility poles.<br><strong><br><\/strong><\/p>\n<p><strong>Key Responsibilities<\/strong><br>    \u2022    Review joint use applications for pole attachments, including telecom, fiber, cable, and wireless equipment installations.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Perform structural and load analysis of utility poles to ensure compliance with design and safety standards.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Evaluate pole capacity and determine make-ready requirements necessary to accommodate new attachments.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Design and specify required upgrades, such as pole replacements, guying, or rearrangements.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Ensure adherence to National Electrical Safety Code (NESC), company standards, and local\/state regulations.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Coordinate with internal departments (engineering, construction, operations) and third-party attachers.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Provide cost estimates and contribute to project timelines for make-ready work.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Review and approve engineering drawings, construction plans, and field data.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Resolve field issues related to pole attachments, including conflicts or clearance violations.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Support field inspections or audits of existing pole conditions and attachments.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Maintain accurate engineering and asset records in GIS or work management systems.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Assist in developing and improving joint use policies, standards, and processes.<br><strong><br><\/strong><\/p>\n<p><strong>Required Qualifications<\/strong><br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Bachelor\u2019s degree in Electrical Engineering, Civil Engineering, or a related field (or equivalent experience).<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;2\u20135+ years of experience in utility distribution engineering, telecommunications, or joint use engineering.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Knowledge of overhead distribution systems and pole line construction practices.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Familiarity with NESC, OSHA regulations, and joint use agreements.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Experience with pole loading analysis software (e.g., O-Calc, SpidaCalc, Katapult, or similar).<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Strong analytical and problem-solving skills.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Ability to interpret engineering drawings and technical specifications.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Excellent communication and coordination skills.<br><strong><br><\/strong><\/p>\n<p><strong>Preferred Qualifications<\/strong><br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Professional Engineer (PE) license or progress toward licensure.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Experience working with electric utilities or telecom providers.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Familiarity with GIS systems and utility asset management databases.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Knowledge of make-ready engineering and FCC pole attachment rules.<br><strong><br><\/strong><\/p>\n<p><strong>Key Competencies<\/strong><br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Attention to detail and safety awareness<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Technical and structural analysis expertise<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Project coordination and stakeholder management<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Regulatory compliance understanding<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Time management and ability to handle multiple projects<br><strong><br><\/strong><\/p>\n<p><strong>Work Environment<\/strong><br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Primarily office-based with occasional field visits.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;May require site inspections in varying weather and terrain conditions.<br>&nbsp;&nbsp;&nbsp;&nbsp;\u2022&nbsp;&nbsp;&nbsp;&nbsp;Interaction with customers, contractors, and regulatory agencies.<\/p>","%category%":"Design","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/8ee80e02ccb9-line-utility-attachment-engineer","%breezy_id%":"8ee80e02ccb9","%breezy_friendly_id%":"8ee80e02ccb9-line-utility-attachment-engineer","%breezy_created_date%":"2026-05-19T12:14:52.339Z","%breezy_updated_date%":"2026-05-20T18:26:20.881Z","%_wpgmp_location_city%":"San Antonio","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"San Antonio, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.4251905","%_wpgmp_metabox_longitude%":"-98.4945922","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"266"}},"id":3641,"infowindow_disable":false},{"source":"post","title":"Paving Screed Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Screed Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-screed-operator\/\" name=\"Paving Screed Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-screed-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt&hellip;","post_content":"<p>Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt paving machine to ensure a smooth, even, and properly compacted surface. This role requires precision, attention to detail, and coordination with the paving crew to meet project specifications and quality standards.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Operate the screed controls on an asphalt paver to regulate depth, width, and smoothness of the asphalt mat<\/li>\n<li>Adjust screed settings to maintain proper grade, slope, and crown according to project plans<\/li>\n<li>Monitor asphalt material flow and temperature to ensure consistent paving quality<\/li>\n<li>Coordinate with the paver operator, roller operators, and ground crew for efficient workflow<\/li>\n<li>Perform routine checks and minor maintenance on screed equipment<\/li>\n<li>Identify and correct surface irregularities during paving operations<\/li>\n<li>Ensure compliance with safety regulations and company policies<\/li>\n<li>Read and interpret project plans, grade stakes, and specifications<\/li>\n<li>Maintain a safe and clean work environment<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>High school diploma or equivalent preferred<\/li>\n<li>2+ years of experience operating paving equipment, specifically screeds<\/li>\n<li>Strong understanding of asphalt paving processes and materials<\/li>\n<li>Ability to read grade stakes, blueprints, and layout drawings<\/li>\n<li>Valid driver\u2019s license (CDL preferred but not always required)<\/li>\n<\/ul>\n<h2><strong>Skills &amp; Competencies<\/strong><\/h2>\n<ul>\n<li>Attention to detail and precision in equipment operation<\/li>\n<li>Strong hand-eye coordination<\/li>\n<li>Ability to work effectively in a team environment<\/li>\n<li>Good communication and problem-solving skills<\/li>\n<li>Mechanical aptitude for equipment troubleshooting<\/li>\n<li>Ability to work in varying weather conditions<\/li>\n<\/ul>\n<h2><strong>Physical Requirements<\/strong><\/h2>\n<ul>\n<li>Ability to stand for long periods and work on uneven surfaces<\/li>\n<li>Frequently lift up to 50 lbs<\/li>\n<li>Ability to work outdoors in hot, cold, and noisy environments<\/li>\n<li>Must be able to bend, stoop, and climb onto equipment<\/li>\n<\/ul><p><\/p><p>This role is based in Bowmansville, PA and is an on-site role.<\/p>","post_title":"Paving Screed Operator","post_link":"https:\/\/turnerstaffing.com\/position\/paving-screed-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p>Our client is looking for a&nbsp;Paving Screed Operator who will be&nbsp;responsible for operating and controlling the screed on an asphalt paving machine to ensure a smooth, even, and properly compacted surface. This role requires precision, attention to detail, and coordination with the paving crew to meet project specifications and quality standards.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Operate the screed controls on an asphalt paver to regulate depth, width, and smoothness of the asphalt mat<\/li>\n<li>Adjust screed settings to maintain proper grade, slope, and crown according to project plans<\/li>\n<li>Monitor asphalt material flow and temperature to ensure consistent paving quality<\/li>\n<li>Coordinate with the paver operator, roller operators, and ground crew for efficient workflow<\/li>\n<li>Perform routine checks and minor maintenance on screed equipment<\/li>\n<li>Identify and correct surface irregularities during paving operations<\/li>\n<li>Ensure compliance with safety regulations and company policies<\/li>\n<li>Read and interpret project plans, grade stakes, and specifications<\/li>\n<li>Maintain a safe and clean work environment<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>High school diploma or equivalent preferred<\/li>\n<li>2+ years of experience operating paving equipment, specifically screeds<\/li>\n<li>Strong understanding of asphalt paving processes and materials<\/li>\n<li>Ability to read grade stakes, blueprints, and layout drawings<\/li>\n<li>Valid driver\u2019s license (CDL preferred but not always required)<\/li>\n<\/ul>\n<h2><strong>Skills &amp; Competencies<\/strong><\/h2>\n<ul>\n<li>Attention to detail and precision in equipment operation<\/li>\n<li>Strong hand-eye coordination<\/li>\n<li>Ability to work effectively in a team environment<\/li>\n<li>Good communication and problem-solving skills<\/li>\n<li>Mechanical aptitude for equipment troubleshooting<\/li>\n<li>Ability to work in varying weather conditions<\/li>\n<\/ul>\n<h2><strong>Physical Requirements<\/strong><\/h2>\n<ul>\n<li>Ability to stand for long periods and work on uneven surfaces<\/li>\n<li>Frequently lift up to 50 lbs<\/li>\n<li>Ability to work outdoors in hot, cold, and noisy environments<\/li>\n<li>Must be able to bend, stoop, and climb onto equipment<\/li>\n<\/ul><p><\/p><p>This role is based in Bowmansville, PA and is an on-site role.<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/c2a93e739a12-paving-screed-operator","%breezy_id%":"c2a93e739a12","%breezy_friendly_id%":"c2a93e739a12-paving-screed-operator","%breezy_created_date%":"2026-05-14T21:26:55.560Z","%breezy_updated_date%":"2026-05-19T12:25:25.744Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"265"}},"id":3640,"infowindow_disable":false},{"source":"post","title":"Health &amp; Safety Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Health &amp; Safety Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Health &amp; Safety Manager serves as a key leader and trusted advisor to site leadership, responsible for driving a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/health-safety-manager\/\" name=\"Health &amp; Safety Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Health &amp; Safety Manager serves as a key leader and trusted advisor to site leadership, responsible for driving a&hellip;","address":"Elko, NVUnited States","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/health-safety-manager\/","zoom":19,"extra_fields":{"post_excerpt":"The Health &amp; Safety Manager serves as a key leader and trusted advisor to site leadership, responsible for driving a&hellip;","post_content":"<p>The Health &amp; Safety Manager serves as a key leader and trusted advisor to site leadership, responsible for driving a proactive, high-performance safety culture across mining operations in Nevada. This role partners closely with operational and technical teams to identify, assess, and mitigate risk while advancing strategic health and safety initiatives.<\/p><p>The position is accountable for developing, implementing, and continuously improving health and safety programs, systems, and standards to ensure compliance with regulatory requirements and company policies while supporting long-term operational readiness and success.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Provide leadership and oversight of all health and safety activities across site operations, ensuring compliance with regulatory and company standards. <\/li><li>Manage team performance by aligning individual goals with organizational objectives, delivering regular performance feedback, and supporting employee development through training and career progression opportunities. <\/li><li>Champion a culture of safety excellence through coaching, mentoring, and visible leadership across all levels of the organization. <\/li><li>Partner with site leadership to proactively identify risks and implement effective mitigation strategies aligned with a Zero Harm philosophy. <\/li><li>Lead and support internal inspections, audits, and risk assessments, ensuring timely and effective corrective actions. <\/li><li>Oversee daily H&amp;S operations, including: <ul><li>Emergency response and medical services <\/li><li>Industrial hygiene and occupational health programs <\/li><li>Safety training, compliance, and assurance systems <\/li><\/ul><\/li><li>Drive continuous improvement initiatives and foster a proactive, data-driven safety culture. <\/li><li>Provide strategic guidance, coaching, and technical expertise to the H&amp;S team and senior leadership. <\/li><li>Lead, develop, and manage the H&amp;S team, including performance management and professional development. <\/li><li>Ensure accurate and timely reporting of safety data to meet internal and regulatory requirements. <\/li><li>Act as the primary liaison with regulatory agencies, including MSHA and OSHA. <\/li><li>Analyze safety data and trends to inform long-term strategies and reduce risk exposure. <\/li><li>Lead and support incident investigations, ensuring root cause analysis and sustainable corrective actions. <\/li><li>Maintain and enhance the site&rsquo;s health and safety management systems and associated standards. <\/li><li>Collaborate with operations and regulatory representatives during inspections and audits. <\/li><li>Engage with contractors and consultants to ensure alignment with site health and safety expectations, policies, and risk management practices. <\/li><li>Support emergency preparedness planning and response readiness across the site. <\/li><li>Participate in corporate health and safety initiatives, including audits, governance programs, and knowledge-sharing forums.<\/li><li>Other duties as assigned.<\/li><\/ul><p><strong>Qualifications<\/strong><\/p><ul><li>Bachelor&rsquo;s degree in Occupational Health &amp; Safety or a related field, or equivalent experience. <\/li><li>7&ndash;10+ years of progressive health and safety experience, preferably in mining, manufacturing, or heavy industry. <\/li><li>Minimum 5 years of leadership or supervisory experience. <\/li><li>Underground mining experience strongly preferred. <\/li><li>MSHA Instructor certification (surface and underground) preferred. <\/li><li>Strong working knowledge of MSHA, OSHA, and applicable state regulations. <\/li><li>Experience in risk management, process safety, and incident investigation. <\/li><li>Professional certifications such as CSP, CIH, or CMSP are considered an asset. <\/li><li>Ability to work in an underground mining environment. <\/li><li>Candidates must be authorized to work in the United States without current or future visa sponsorship. <\/li><\/ul><p><strong>Equal Employment Opportunity<\/strong><\/p><p>The Company is an equal opportunity employer committed to creating an inclusive workplace and complying with all applicable employment laws.<\/p>","post_title":"Health &amp; Safety Manager","post_link":"https:\/\/turnerstaffing.com\/position\/health-safety-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_city_state%":"Elko, NV","%description%":"<p>The Health &amp; Safety Manager serves as a key leader and trusted advisor to site leadership, responsible for driving a proactive, high-performance safety culture across mining operations in Nevada. This role partners closely with operational and technical teams to identify, assess, and mitigate risk while advancing strategic health and safety initiatives.<\/p><p>The position is accountable for developing, implementing, and continuously improving health and safety programs, systems, and standards to ensure compliance with regulatory requirements and company policies while supporting long-term operational readiness and success.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Provide leadership and oversight of all health and safety activities across site operations, ensuring compliance with regulatory and company standards. <\/li><li>Manage team performance by aligning individual goals with organizational objectives, delivering regular performance feedback, and supporting employee development through training and career progression opportunities. <\/li><li>Champion a culture of safety excellence through coaching, mentoring, and visible leadership across all levels of the organization. <\/li><li>Partner with site leadership to proactively identify risks and implement effective mitigation strategies aligned with a Zero Harm philosophy. <\/li><li>Lead and support internal inspections, audits, and risk assessments, ensuring timely and effective corrective actions. <\/li><li>Oversee daily H&amp;S operations, including: <ul><li>Emergency response and medical services <\/li><li>Industrial hygiene and occupational health programs <\/li><li>Safety training, compliance, and assurance systems <\/li><\/ul><\/li><li>Drive continuous improvement initiatives and foster a proactive, data-driven safety culture. <\/li><li>Provide strategic guidance, coaching, and technical expertise to the H&amp;S team and senior leadership. <\/li><li>Lead, develop, and manage the H&amp;S team, including performance management and professional development. <\/li><li>Ensure accurate and timely reporting of safety data to meet internal and regulatory requirements. <\/li><li>Act as the primary liaison with regulatory agencies, including MSHA and OSHA. <\/li><li>Analyze safety data and trends to inform long-term strategies and reduce risk exposure. <\/li><li>Lead and support incident investigations, ensuring root cause analysis and sustainable corrective actions. <\/li><li>Maintain and enhance the site&rsquo;s health and safety management systems and associated standards. <\/li><li>Collaborate with operations and regulatory representatives during inspections and audits. <\/li><li>Engage with contractors and consultants to ensure alignment with site health and safety expectations, policies, and risk management practices. <\/li><li>Support emergency preparedness planning and response readiness across the site. <\/li><li>Participate in corporate health and safety initiatives, including audits, governance programs, and knowledge-sharing forums.<\/li><li>Other duties as assigned.<\/li><\/ul><p><strong>Qualifications<\/strong><\/p><ul><li>Bachelor&rsquo;s degree in Occupational Health &amp; Safety or a related field, or equivalent experience. <\/li><li>7&ndash;10+ years of progressive health and safety experience, preferably in mining, manufacturing, or heavy industry. <\/li><li>Minimum 5 years of leadership or supervisory experience. <\/li><li>Underground mining experience strongly preferred. <\/li><li>MSHA Instructor certification (surface and underground) preferred. <\/li><li>Strong working knowledge of MSHA, OSHA, and applicable state regulations. <\/li><li>Experience in risk management, process safety, and incident investigation. <\/li><li>Professional certifications such as CSP, CIH, or CMSP are considered an asset. <\/li><li>Ability to work in an underground mining environment. <\/li><li>Candidates must be authorized to work in the United States without current or future visa sponsorship. <\/li><\/ul><p><strong>Equal Employment Opportunity<\/strong><\/p><p>The Company is an equal opportunity employer committed to creating an inclusive workplace and complying with all applicable employment laws.<\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/asgz87tkm8forcd6y6g69uf4io","%crelate_id%":"asgz87tkm8forcd6y6g69uf4io","%crelate_created_date%":"2026-05-18T19:18:39.39Z","%crelate_updated_date%":"2026-06-11T11:08:11.89Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NVUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":3639,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling-3\/\" name=\"Haul Truck Operator &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling-3\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;","post_content":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Operator<br>\n<strong>Schedule:<\/strong> 12-hour shifts<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and safety-focused <strong>Haul Truck Operator<\/strong> to join our mining operations team. This role is responsible for safely operating heavy haul trucks in an active mine environment to transport material efficiently and in accordance with site safety standards. The ideal candidate will have a minimum of 2 years of experience operating <strong>40-ton to 100-ton haul trucks<\/strong> and must be willing to work 12-hour shifts, and be open to&nbsp;day and night schedules.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSafely operate mine haul trucks in an active mining environment\n<\/li>\n<li>\nTransport materials efficiently to designated locations\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nReport mechanical issues, safety concerns, or unsafe conditions immediately\n<\/li>\n<li>\nFollow all site safety procedures, traffic patterns, and operational rules\n<\/li>\n<li>\nCommunicate effectively with supervisors, dispatch, and other equipment operators\n<\/li>\n<li>\nMaintain productivity while operating equipment safely and responsibly\n<\/li>\n<li>\nAssist with other duties as needed to support site operations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of <strong>2 years of experience<\/strong> operating <strong>40-ton to 100-ton haul trucks<\/strong>\n<\/li>\n<li>\nPrevious mining or heavy civil experience preferred\n<\/li>\n<li>\nMust be able to work <strong>12-hour shifts<\/strong>\n<\/li>\n<li>\nMust be open to <strong>day and night shift schedules<\/strong>\n<\/li>\n<li>\nStrong understanding of safe equipment operation and site awareness\n<\/li>\n<li>\n<strong>MSHA certification preferred<\/strong>\n<\/li>\n<li>\nValid driver\u2019s license&nbsp;<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibration, and varying weather conditions\n<\/li>\n<li>\nWork around heavy equipment, trucks, and active site traffic\n<\/li>\n<li>\nPhysically demanding role requiring attention to detail and strong safety awareness<\/li><\/ul>","post_title":"Haul Truck Operator &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Operator<br>\n<strong>Schedule:<\/strong> 12-hour shifts<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and safety-focused <strong>Haul Truck Operator<\/strong> to join our mining operations team. This role is responsible for safely operating heavy haul trucks in an active mine environment to transport material efficiently and in accordance with site safety standards. The ideal candidate will have a minimum of 2 years of experience operating <strong>40-ton to 100-ton haul trucks<\/strong> and must be willing to work 12-hour shifts, and be open to&nbsp;day and night schedules.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSafely operate mine haul trucks in an active mining environment\n<\/li>\n<li>\nTransport materials efficiently to designated locations\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nReport mechanical issues, safety concerns, or unsafe conditions immediately\n<\/li>\n<li>\nFollow all site safety procedures, traffic patterns, and operational rules\n<\/li>\n<li>\nCommunicate effectively with supervisors, dispatch, and other equipment operators\n<\/li>\n<li>\nMaintain productivity while operating equipment safely and responsibly\n<\/li>\n<li>\nAssist with other duties as needed to support site operations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of <strong>2 years of experience<\/strong> operating <strong>40-ton to 100-ton haul trucks<\/strong>\n<\/li>\n<li>\nPrevious mining or heavy civil experience preferred\n<\/li>\n<li>\nMust be able to work <strong>12-hour shifts<\/strong>\n<\/li>\n<li>\nMust be open to <strong>day and night shift schedules<\/strong>\n<\/li>\n<li>\nStrong understanding of safe equipment operation and site awareness\n<\/li>\n<li>\n<strong>MSHA certification preferred<\/strong>\n<\/li>\n<li>\nValid driver\u2019s license&nbsp;<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibration, and varying weather conditions\n<\/li>\n<li>\nWork around heavy equipment, trucks, and active site traffic\n<\/li>\n<li>\nPhysically demanding role requiring attention to detail and strong safety awareness<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/240c969efd6d-haul-truck-operator-traveling","%breezy_id%":"240c969efd6d","%breezy_friendly_id%":"240c969efd6d-haul-truck-operator-traveling","%breezy_created_date%":"2026-05-18T21:00:09.359Z","%breezy_updated_date%":"2026-05-18T21:00:27.196Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"264"}},"id":3638,"infowindow_disable":false},{"source":"post","title":"Surveyor -Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Surveyor -Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Mine Surveyor Position Overview We are seeking a skilled Mine Surveyor to support daily mining operations through accurate&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/surveyor-traveling-2\/\" name=\"Surveyor -Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Mine Surveyor Position Overview We are seeking a skilled Mine Surveyor to support daily mining operations through accurate&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/surveyor-traveling-2\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Mine Surveyor Position Overview We are seeking a skilled Mine Surveyor to support daily mining operations through accurate&hellip;","post_content":"<p><strong>Job Title:<\/strong> Mine Surveyor<br><\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a skilled <strong>Mine Surveyor<\/strong> to support daily mining operations through accurate layout, data management, and field surveying. This role is critical to ensuring safe and efficient production by providing precise survey control, maintaining equipment, and coordinating with engineering and operations teams. Candidates with mining or heavy civil construction surveying experience are encouraged to apply.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nPerform survey functions in support of mine operations and project scope\n<\/li>\n<li>\nConduct daily field staking and layout in accordance with mine plans and designs\n<\/li>\n<li>\nComplete quantity takeoffs, volume calculations, and material tracking\n<\/li>\n<li>\nCommunicate layout and survey data clearly to operators, supervisors, and site personnel\n<\/li>\n<li>\nTroubleshoot survey layouts and machine control data to ensure accuracy and consistency\n<\/li>\n<li>\nMaintain, calibrate, troubleshoot, and repair survey equipment\n<\/li>\n<li>\nCoordinate with mine engineers and design teams regarding plans, updates, and changes\n<\/li>\n<li>\nEnsure all survey work meets project specifications and quality standards\n<\/li>\n<li>\nOperate and communicate via 2-way radio\n<\/li>\n<li>\nMaintain accurate survey records and documentation\n<\/li>\n<\/ul>\n<h3><strong>Safety &amp; Compliance<\/strong><\/h3>\n<ul>\n<li>\nAdhere to all company safety policies, procedures, and PPE requirements\n<\/li>\n<li>\nConduct Job Safety Analyses (JSA) and Field Level Hazard Assessments (FLHA) as required\n<\/li>\n<li>\nMaintain strong situational awareness of heavy equipment, personnel, and site hazards\n<\/li>\n<li>\nSupport and promote a strong safety culture on site\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of 2+ years of surveying experience (mining or construction)\n<\/li>\n<li>\nExtensive GPS construction layout experience using Trimble or Topcon equipment\n<\/li>\n<li>\nExperience with machine control systems preferred\n<\/li>\n<li>\nHigh School Diploma required\n<\/li>\n<li>\nPost-secondary education in surveying or related field (technical school preferred)\n<\/li>\n<li>\nAbility to read and interpret mine plans, engineering drawings, and specifications\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\nStrong problem-solving and troubleshooting skills\n<\/li>\n<li>\nHigh level of accuracy and attention to detail\n<\/li>\n<li>\nAbility to work independently and within a team environment\n<\/li>\n<li>\nEffective communication across multiple departments\n<\/li>\n<li>\nAdaptability in a fast-paced, production-driven environment\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibrations, and varying weather conditions\n<\/li>\n<li>\nAbility to safely and repetitively lift up to 50 lbs\n<\/li>\n<li>\nPhysically demanding role requiring standing, walking, and climbing<\/li>\n<li>\nFlexibility to assist with general labor duties as needed<\/li><\/ul>","post_title":"Surveyor -Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/surveyor-traveling-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong> Mine Surveyor<br><\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a skilled <strong>Mine Surveyor<\/strong> to support daily mining operations through accurate layout, data management, and field surveying. This role is critical to ensuring safe and efficient production by providing precise survey control, maintaining equipment, and coordinating with engineering and operations teams. Candidates with mining or heavy civil construction surveying experience are encouraged to apply.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nPerform survey functions in support of mine operations and project scope\n<\/li>\n<li>\nConduct daily field staking and layout in accordance with mine plans and designs\n<\/li>\n<li>\nComplete quantity takeoffs, volume calculations, and material tracking\n<\/li>\n<li>\nCommunicate layout and survey data clearly to operators, supervisors, and site personnel\n<\/li>\n<li>\nTroubleshoot survey layouts and machine control data to ensure accuracy and consistency\n<\/li>\n<li>\nMaintain, calibrate, troubleshoot, and repair survey equipment\n<\/li>\n<li>\nCoordinate with mine engineers and design teams regarding plans, updates, and changes\n<\/li>\n<li>\nEnsure all survey work meets project specifications and quality standards\n<\/li>\n<li>\nOperate and communicate via 2-way radio\n<\/li>\n<li>\nMaintain accurate survey records and documentation\n<\/li>\n<\/ul>\n<h3><strong>Safety &amp; Compliance<\/strong><\/h3>\n<ul>\n<li>\nAdhere to all company safety policies, procedures, and PPE requirements\n<\/li>\n<li>\nConduct Job Safety Analyses (JSA) and Field Level Hazard Assessments (FLHA) as required\n<\/li>\n<li>\nMaintain strong situational awareness of heavy equipment, personnel, and site hazards\n<\/li>\n<li>\nSupport and promote a strong safety culture on site\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of 2+ years of surveying experience (mining or construction)\n<\/li>\n<li>\nExtensive GPS construction layout experience using Trimble or Topcon equipment\n<\/li>\n<li>\nExperience with machine control systems preferred\n<\/li>\n<li>\nHigh School Diploma required\n<\/li>\n<li>\nPost-secondary education in surveying or related field (technical school preferred)\n<\/li>\n<li>\nAbility to read and interpret mine plans, engineering drawings, and specifications\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\nStrong problem-solving and troubleshooting skills\n<\/li>\n<li>\nHigh level of accuracy and attention to detail\n<\/li>\n<li>\nAbility to work independently and within a team environment\n<\/li>\n<li>\nEffective communication across multiple departments\n<\/li>\n<li>\nAdaptability in a fast-paced, production-driven environment\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibrations, and varying weather conditions\n<\/li>\n<li>\nAbility to safely and repetitively lift up to 50 lbs\n<\/li>\n<li>\nPhysically demanding role requiring standing, walking, and climbing<\/li>\n<li>\nFlexibility to assist with general labor duties as needed<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/f70cc3a5afd1-surveyor-traveling","%breezy_id%":"f70cc3a5afd1","%breezy_friendly_id%":"f70cc3a5afd1-surveyor-traveling","%breezy_created_date%":"2026-04-20T17:06:49.211Z","%breezy_updated_date%":"2026-05-18T20:59:11.587Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"263"}},"id":3637,"infowindow_disable":false},{"source":"post","title":"Safety Advisor &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Safety Advisor &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Summary Turner Staffing Group is seeking an experienced Health &amp; Safety Advisor to support heavy civil, construction, road building,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/safety-advisor-traveling\/\" name=\"Safety Advisor &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Summary Turner Staffing Group is seeking an experienced Health &amp; Safety Advisor to support heavy civil, construction, road building,&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/safety-advisor-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"Position Summary Turner Staffing Group is seeking an experienced Health &amp; Safety Advisor to support heavy civil, construction, road building,&hellip;","post_content":"<h3>Position Summary<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Health &amp; Safety Advisor<\/strong> to support heavy civil, construction, road building, and mining project sites. This field\u2011based role focuses on promoting a strong safety culture, ensuring regulatory compliance, and providing hands\u2011on safety leadership across multiple project locations.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>Deliver field\u2011level safety orientations and lead safety meetings<\/li>\n<li>Promote and model safe work behaviors and best practices<\/li>\n<li>Conduct site inspections, audits, and hazard assessments<\/li>\n<li>Support incident and near\u2011miss investigations<\/li>\n<li>Monitor compliance with Turner Staffing Group\u2019s Safe Work Practices and PPE policies<\/li>\n<li>Collaborate with workers, supervisors, and management to identify and mitigate hazards<\/li>\n<li>Track safety trends and recommend continuous improvements<\/li>\n<li>Travel to multiple project sites as required<\/li>\n<\/ul>\n<h3>Requirements<\/h3>\n<ul>\n<li>Minimum <strong>5 years\u2019 experience<\/strong> as a Health &amp; Safety Advisor in heavy civil, construction, or mining environments<\/li>\n<li>Strong knowledge of <strong>provincial OH&amp;S regulations<\/strong><\/li>\n<li>MSHA Part 48 certification or ability to obtain<\/li>\n<li>Alcohol and Drug Screening (pre\u2011employment)<\/li>\n<li>Ability to lift up to <strong>50 lbs<\/strong> and work <strong>12\u2011hour rotational day\/night shifts<\/strong><\/li>\n<li>Comfortable working outdoors in all weather conditions<\/li>\n<li>Strong communication, organization, and problem\u2011solving skills<\/li>\n<li>High school diploma required; post\u2011secondary education an asset<\/li><\/ul>\n<p><\/p>","post_title":"Safety Advisor &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/safety-advisor-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>Position Summary<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Health &amp; Safety Advisor<\/strong> to support heavy civil, construction, road building, and mining project sites. This field\u2011based role focuses on promoting a strong safety culture, ensuring regulatory compliance, and providing hands\u2011on safety leadership across multiple project locations.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>Deliver field\u2011level safety orientations and lead safety meetings<\/li>\n<li>Promote and model safe work behaviors and best practices<\/li>\n<li>Conduct site inspections, audits, and hazard assessments<\/li>\n<li>Support incident and near\u2011miss investigations<\/li>\n<li>Monitor compliance with Turner Staffing Group\u2019s Safe Work Practices and PPE policies<\/li>\n<li>Collaborate with workers, supervisors, and management to identify and mitigate hazards<\/li>\n<li>Track safety trends and recommend continuous improvements<\/li>\n<li>Travel to multiple project sites as required<\/li>\n<\/ul>\n<h3>Requirements<\/h3>\n<ul>\n<li>Minimum <strong>5 years\u2019 experience<\/strong> as a Health &amp; Safety Advisor in heavy civil, construction, or mining environments<\/li>\n<li>Strong knowledge of <strong>provincial OH&amp;S regulations<\/strong><\/li>\n<li>MSHA Part 48 certification or ability to obtain<\/li>\n<li>Alcohol and Drug Screening (pre\u2011employment)<\/li>\n<li>Ability to lift up to <strong>50 lbs<\/strong> and work <strong>12\u2011hour rotational day\/night shifts<\/strong><\/li>\n<li>Comfortable working outdoors in all weather conditions<\/li>\n<li>Strong communication, organization, and problem\u2011solving skills<\/li>\n<li>High school diploma required; post\u2011secondary education an asset<\/li><\/ul>\n<p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/11d271db7df1-safety-advisor-traveling","%breezy_id%":"11d271db7df1","%breezy_friendly_id%":"11d271db7df1-safety-advisor-traveling","%breezy_created_date%":"2026-04-17T23:53:13.914Z","%breezy_updated_date%":"2026-05-18T20:58:49.197Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"262"}},"id":3636,"infowindow_disable":false},{"source":"post","title":"Mining Foreman &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Foreman &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-foreman-traveling-2\/\" name=\"Mining Foreman &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-foreman-traveling-2\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety, and operational excellence. We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nSupervise and direct daily activities of mining crews, equipment operators, and labor personnel\n<\/li>\n<li>\nCoordinate production schedules to meet daily and weekly output targets\n<\/li>\n<li>\nMonitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures\n<\/li>\n<li>\nEnforce mine safety standards, company policies, and MSHA regulations at all times\n<\/li>\n<li>\nConduct pre-shift meetings, safety briefings, and crew assignments\n<\/li>\n<li>\nInspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies\n<\/li>\n<li>\nCommunicate with management regarding production progress, staffing needs, and operational concerns\n<\/li>\n<li>\nEnsure equipment is being operated properly and maintenance issues are reported promptly\n<\/li>\n<li>\nTrain and mentor crew members on safe work practices and operational procedures\n<\/li>\n<li>\nMaintain accurate shift reports, production logs, and incident documentation\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious supervisory experience in mining operations required\n<\/li>\n<li>\nStrong knowledge of surface or underground mining processes (depending on site application)\n<\/li>\n<li>\nExperience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers\n<\/li>\n<li>\nMSHA certification required or ability to obtain\/maintain certification as required by site\n<\/li>\n<li>\nProven leadership, communication, and decision-making skills\n<\/li>\n<li>\nAbility to prioritize tasks and manage multiple crews in a fast-paced environment\n<\/li>\n<li>\nStrong understanding of workplace safety and hazard recognition practices\n<\/li>\n<li>\nProficient in basic reporting, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to work in active mining environments, including exposure to dust, noise, and varying weather conditions\n<\/li>\n<li>\nAbility to walk uneven terrain, climb equipment\/access points, and remain active throughout shift\n<\/li>\n<li>\nAbility to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to wear all required PPE on site<\/li><\/ul>","post_title":"Mining Foreman &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/mining-foreman-traveling-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety, and operational excellence. We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nSupervise and direct daily activities of mining crews, equipment operators, and labor personnel\n<\/li>\n<li>\nCoordinate production schedules to meet daily and weekly output targets\n<\/li>\n<li>\nMonitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures\n<\/li>\n<li>\nEnforce mine safety standards, company policies, and MSHA regulations at all times\n<\/li>\n<li>\nConduct pre-shift meetings, safety briefings, and crew assignments\n<\/li>\n<li>\nInspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies\n<\/li>\n<li>\nCommunicate with management regarding production progress, staffing needs, and operational concerns\n<\/li>\n<li>\nEnsure equipment is being operated properly and maintenance issues are reported promptly\n<\/li>\n<li>\nTrain and mentor crew members on safe work practices and operational procedures\n<\/li>\n<li>\nMaintain accurate shift reports, production logs, and incident documentation\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious supervisory experience in mining operations required\n<\/li>\n<li>\nStrong knowledge of surface or underground mining processes (depending on site application)\n<\/li>\n<li>\nExperience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers\n<\/li>\n<li>\nMSHA certification required or ability to obtain\/maintain certification as required by site\n<\/li>\n<li>\nProven leadership, communication, and decision-making skills\n<\/li>\n<li>\nAbility to prioritize tasks and manage multiple crews in a fast-paced environment\n<\/li>\n<li>\nStrong understanding of workplace safety and hazard recognition practices\n<\/li>\n<li>\nProficient in basic reporting, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to work in active mining environments, including exposure to dust, noise, and varying weather conditions\n<\/li>\n<li>\nAbility to walk uneven terrain, climb equipment\/access points, and remain active throughout shift\n<\/li>\n<li>\nAbility to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to wear all required PPE on site<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/d2f03008149d-mining-foreman-traveling","%breezy_id%":"d2f03008149d","%breezy_friendly_id%":"d2f03008149d-mining-foreman-traveling","%breezy_created_date%":"2026-04-10T18:21:37.242Z","%breezy_updated_date%":"2026-05-20T12:49:27.003Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"261"}},"id":3635,"infowindow_disable":false},{"source":"post","title":"Water Truck Operator &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Water Truck Operator &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About the Opportunity Turner Staffing Group is seeking a Water Truck Operator to support surface operations at the Jerritt Canyon&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/water-truck-operator-traveling\/\" name=\"Water Truck Operator &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About the Opportunity Turner Staffing Group is seeking a Water Truck Operator to support surface operations at the Jerritt Canyon&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/water-truck-operator-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"About the Opportunity Turner Staffing Group is seeking a Water Truck Operator to support surface operations at the Jerritt Canyon&hellip;","post_content":"<h3>About the Opportunity<\/h3>\n<p>Turner Staffing Group is seeking a <strong>Water Truck Operator<\/strong> to support surface operations at the Jerritt Canyon Mine in Elko, Nevada. This is a project-based role supporting underground mine restart activities, offering an opportunity to work on a high-impact mining operation.<\/p>\n<p>This position is ideal for individuals who prioritize safety, take pride in equipment operation, and can work effectively in dynamic site conditions.<\/p>\n<h3>Key Responsibilities<\/h3>\n<p>As a Water Truck Operator, you will:<\/p>\n<ul>\n<li>\nSafely operate an 8,000-gallon water truck in accordance with site rules and manufacturer guidelines\n<\/li>\n<li>\nPerform and document pre-operational inspections (fluids, tires, brakes, lights, articulation joint, etc.)\n<\/li>\n<li>\nMaintain full control of the vehicle across varying road and weather conditions\n<\/li>\n<li>\nEnsure safe loading, transport, and controlled discharge of water\n<\/li>\n<li>\nMonitor tank systems, including hoses, valves, and pumps, for proper function\n<\/li>\n<li>\nCommunicate effectively using site radio and follow all traffic protocols\n<\/li>\n<li>\nReport hazards, incidents, and mechanical issues immediately\n<\/li>\n<li>\nComplete all required logs, reports, and documentation\n<\/li>\n<\/ul>\n<h3>Work Activities<\/h3>\n<ul>\n<li>\nConduct daily equipment inspections and post-operation checks\n<\/li>\n<li>\nVerify system integrity (tank, valves, pump functionality)\n<\/li>\n<li>\nOperate only on approved haul routes and maintain safe speeds\n<\/li>\n<li>\nMaintain safe following distances and situational awareness\n<\/li>\n<li>\nPosition equipment safely for water discharge operations\n<\/li>\n<li>\nPrevent spills, overflows, erosion, or unsafe discharge conditions\n<\/li>\n<li>\nFollow proper parking, shutdown, and lockout procedures when required\n<\/li>\n<\/ul>\n<h3>Equipment Operated<\/h3>\n<ul>\n<li>\nVolvo A40G Water Truck (8,000-gallon capacity)\n<\/li>\n<li>\nOnboard pumping and spray systems\n<\/li>\n<li>\nSite communication systems (radio)\n<\/li>\n<li>\nStandard safety equipment (fire extinguisher, spill kit, emergency supplies)\n<\/li>\n<\/ul>\n<h3>Safety Expectations<\/h3>\n<p>Safety is a core value at Turner Staffing Group. All operators are expected to:<\/p>\n<ul>\n<li>\nComply with all site-specific safety policies and MSHA regulations\n<\/li>\n<li>\nWear required PPE at all times\n<\/li>\n<li>\nMaintain awareness of surroundings (personnel, equipment, terrain)\n<\/li>\n<li>\nFollow traffic management and right-of-way rules\n<\/li>\n<li>\nMonitor ground conditions, including slopes and soft areas\n<\/li>\n<li>\nPrevent water-related hazards such as spills, icing, or runoff\n<\/li>\n<li>\nAdhere to fatigue management and work\/rest schedules\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating water trucks or similar heavy equipment preferred\n<\/li>\n<li>\nStrong commitment to safety and operational excellence\n<\/li>\n<li>\nAbility to perform inspections and basic equipment checks\n<\/li>\n<li>\nEffective communication skills and ability to follow site procedures\n<\/li>\n<li>\nMSHA certification (or willingness to obtain prior to start)<\/li><\/ul>","post_title":"Water Truck Operator &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/water-truck-operator-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Temporary","%experience%":"Associate","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About the Opportunity<\/h3>\n<p>Turner Staffing Group is seeking a <strong>Water Truck Operator<\/strong> to support surface operations at the Jerritt Canyon Mine in Elko, Nevada. This is a project-based role supporting underground mine restart activities, offering an opportunity to work on a high-impact mining operation.<\/p>\n<p>This position is ideal for individuals who prioritize safety, take pride in equipment operation, and can work effectively in dynamic site conditions.<\/p>\n<h3>Key Responsibilities<\/h3>\n<p>As a Water Truck Operator, you will:<\/p>\n<ul>\n<li>\nSafely operate an 8,000-gallon water truck in accordance with site rules and manufacturer guidelines\n<\/li>\n<li>\nPerform and document pre-operational inspections (fluids, tires, brakes, lights, articulation joint, etc.)\n<\/li>\n<li>\nMaintain full control of the vehicle across varying road and weather conditions\n<\/li>\n<li>\nEnsure safe loading, transport, and controlled discharge of water\n<\/li>\n<li>\nMonitor tank systems, including hoses, valves, and pumps, for proper function\n<\/li>\n<li>\nCommunicate effectively using site radio and follow all traffic protocols\n<\/li>\n<li>\nReport hazards, incidents, and mechanical issues immediately\n<\/li>\n<li>\nComplete all required logs, reports, and documentation\n<\/li>\n<\/ul>\n<h3>Work Activities<\/h3>\n<ul>\n<li>\nConduct daily equipment inspections and post-operation checks\n<\/li>\n<li>\nVerify system integrity (tank, valves, pump functionality)\n<\/li>\n<li>\nOperate only on approved haul routes and maintain safe speeds\n<\/li>\n<li>\nMaintain safe following distances and situational awareness\n<\/li>\n<li>\nPosition equipment safely for water discharge operations\n<\/li>\n<li>\nPrevent spills, overflows, erosion, or unsafe discharge conditions\n<\/li>\n<li>\nFollow proper parking, shutdown, and lockout procedures when required\n<\/li>\n<\/ul>\n<h3>Equipment Operated<\/h3>\n<ul>\n<li>\nVolvo A40G Water Truck (8,000-gallon capacity)\n<\/li>\n<li>\nOnboard pumping and spray systems\n<\/li>\n<li>\nSite communication systems (radio)\n<\/li>\n<li>\nStandard safety equipment (fire extinguisher, spill kit, emergency supplies)\n<\/li>\n<\/ul>\n<h3>Safety Expectations<\/h3>\n<p>Safety is a core value at Turner Staffing Group. All operators are expected to:<\/p>\n<ul>\n<li>\nComply with all site-specific safety policies and MSHA regulations\n<\/li>\n<li>\nWear required PPE at all times\n<\/li>\n<li>\nMaintain awareness of surroundings (personnel, equipment, terrain)\n<\/li>\n<li>\nFollow traffic management and right-of-way rules\n<\/li>\n<li>\nMonitor ground conditions, including slopes and soft areas\n<\/li>\n<li>\nPrevent water-related hazards such as spills, icing, or runoff\n<\/li>\n<li>\nAdhere to fatigue management and work\/rest schedules\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating water trucks or similar heavy equipment preferred\n<\/li>\n<li>\nStrong commitment to safety and operational excellence\n<\/li>\n<li>\nAbility to perform inspections and basic equipment checks\n<\/li>\n<li>\nEffective communication skills and ability to follow site procedures\n<\/li>\n<li>\nMSHA certification (or willingness to obtain prior to start)<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/49d8ff86d3b5-water-truck-operator-traveling","%breezy_id%":"49d8ff86d3b5","%breezy_friendly_id%":"49d8ff86d3b5-water-truck-operator-traveling","%breezy_created_date%":"2026-04-02T12:40:46.293Z","%breezy_updated_date%":"2026-05-18T20:57:28.531Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"260"}},"id":3634,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling-2\/\" name=\"Haul Truck Operator &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;","address":"Winnemucca, NV, USA","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling-2\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;","post_content":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Operator<br>\n<strong>Schedule:<\/strong> 12-hour shifts<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and safety-focused <strong>Haul Truck Operator<\/strong> to join our mining operations team. This role is responsible for safely operating heavy haul trucks in an active mine environment to transport material efficiently and in accordance with site safety standards. The ideal candidate will have a minimum of 2 years of experience operating <strong>40-ton to 100-ton haul trucks<\/strong> and must be willing to work 12-hour shifts, and be open to&nbsp;day and night schedules.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSafely operate mine haul trucks in an active mining environment\n<\/li>\n<li>\nTransport materials efficiently to designated locations\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nReport mechanical issues, safety concerns, or unsafe conditions immediately\n<\/li>\n<li>\nFollow all site safety procedures, traffic patterns, and operational rules\n<\/li>\n<li>\nCommunicate effectively with supervisors, dispatch, and other equipment operators\n<\/li>\n<li>\nMaintain productivity while operating equipment safely and responsibly\n<\/li>\n<li>\nAssist with other duties as needed to support site operations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of <strong>2 years of experience<\/strong> operating <strong>40-ton to 100-ton haul trucks<\/strong>\n<\/li>\n<li>\nPrevious mining or heavy civil experience preferred\n<\/li>\n<li>\nMust be able to work <strong>12-hour shifts<\/strong>\n<\/li>\n<li>\nMust be open to <strong>day and night shift schedules<\/strong>\n<\/li>\n<li>\nStrong understanding of safe equipment operation and site awareness\n<\/li>\n<li>\n<strong>MSHA certification preferred<\/strong>\n<\/li>\n<li>\nValid driver\u2019s license&nbsp;<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibration, and varying weather conditions\n<\/li>\n<li>\nWork around heavy equipment, trucks, and active site traffic\n<\/li>\n<li>\nPhysically demanding role requiring attention to detail and strong safety awareness<\/li><\/ul>","post_title":"Haul Truck Operator &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Winnemucca, NV","%education%":"","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Operator<br>\n<strong>Schedule:<\/strong> 12-hour shifts<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and safety-focused <strong>Haul Truck Operator<\/strong> to join our mining operations team. This role is responsible for safely operating heavy haul trucks in an active mine environment to transport material efficiently and in accordance with site safety standards. The ideal candidate will have a minimum of 2 years of experience operating <strong>40-ton to 100-ton haul trucks<\/strong> and must be willing to work 12-hour shifts, and be open to&nbsp;day and night schedules.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSafely operate mine haul trucks in an active mining environment\n<\/li>\n<li>\nTransport materials efficiently to designated locations\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nReport mechanical issues, safety concerns, or unsafe conditions immediately\n<\/li>\n<li>\nFollow all site safety procedures, traffic patterns, and operational rules\n<\/li>\n<li>\nCommunicate effectively with supervisors, dispatch, and other equipment operators\n<\/li>\n<li>\nMaintain productivity while operating equipment safely and responsibly\n<\/li>\n<li>\nAssist with other duties as needed to support site operations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of <strong>2 years of experience<\/strong> operating <strong>40-ton to 100-ton haul trucks<\/strong>\n<\/li>\n<li>\nPrevious mining or heavy civil experience preferred\n<\/li>\n<li>\nMust be able to work <strong>12-hour shifts<\/strong>\n<\/li>\n<li>\nMust be open to <strong>day and night shift schedules<\/strong>\n<\/li>\n<li>\nStrong understanding of safe equipment operation and site awareness\n<\/li>\n<li>\n<strong>MSHA certification preferred<\/strong>\n<\/li>\n<li>\nValid driver\u2019s license&nbsp;<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibration, and varying weather conditions\n<\/li>\n<li>\nWork around heavy equipment, trucks, and active site traffic\n<\/li>\n<li>\nPhysically demanding role requiring attention to detail and strong safety awareness<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/1ad7fc8a4670-haul-truck-operator-traveling","%breezy_id%":"1ad7fc8a4670","%breezy_friendly_id%":"1ad7fc8a4670-haul-truck-operator-traveling","%breezy_created_date%":"2026-05-18T20:54:45.326Z","%breezy_updated_date%":"2026-05-20T13:24:48.384Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"259"}},"id":3633,"infowindow_disable":false},{"source":"post","title":"LiDAR Subject Matter Expert","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    LiDAR Subject Matter Expert\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview Our client is seeking a highly motivated and detail-oriented LiDAR Subject Matter Expert (SME) to support telecom and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lidar-subject-matter-expert\/\" name=\"LiDAR Subject Matter Expert\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview Our client is seeking a highly motivated and detail-oriented LiDAR Subject Matter Expert (SME) to support telecom and&hellip;","address":"San Antonio, TX, USA","location":{"lat":"29.4251905","city":"San Antonio","state":"TX","country":"United States","lng":"-98.4945922","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/lidar-subject-matter-expert\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview Our client is seeking a highly motivated and detail-oriented LiDAR Subject Matter Expert (SME) to support telecom and&hellip;","post_content":"<h2>Position Overview<\/h2>\n<p>Our client is seeking a highly motivated and detail-oriented LiDAR Subject Matter Expert (SME) to support telecom and infrastructure projects through advanced geospatial data analysis and technical guidance. This role is ideal for a candidate with strong experience in LiDAR processing, GIS platforms, and point cloud analysis who thrives in a collaborative, fast-paced environment.<\/p>\n<p>The LiDAR SME will serve as a technical resource responsible for reviewing terrestrial, aerial, and mobile LiDAR collection data gathered by field survey and drone pilot teams. This individual will evaluate deliverables for quality, accuracy, and usability while providing actionable feedback and recommendations to both internal stakeholders and end customers regarding project logistics, collection optimization, and workflow improvements.<\/p>\n<p>The ideal candidate combines technical expertise with excellent communication and documentation skills, helping establish best practices, create SOPs, and support continuous improvement initiatives across the organization.<\/p>\n<h2>Key Responsibilities<\/h2>\n<ul>\n<li>\nReview and analyze LiDAR collection datasets from terrestrial, aerial, and mobile platforms\n<\/li>\n<li>\nPerform quality assurance and quality control (QA\/QC) on point cloud data and geospatial deliverables\n<\/li>\n<li>\nApply techniques such as noise reduction, point cloud clarification, classification, and data refinement\n<\/li>\n<li>\nCollaborate with survey crews, drone pilots, GIS specialists, and project managers to improve collection workflows and project execution\n<\/li>\n<li>\nProvide technical feedback and recommendations to customers regarding telecom project logistics, data quality, and operational efficiencies\n<\/li>\n<li>\nInterpret and validate geospatial data using platforms such as ArcGIS, AutoCAD\/Civil 3D, and related GIS\/CAD tools\n<\/li>\n<li>\nDevelop and maintain SOPs, technical documentation, workflow guides, and training materials\n<\/li>\n<li>\nSupport process standardization and continuous improvement initiatives across LiDAR operations\n<\/li>\n<li>\nAssist with troubleshooting data collection or processing issues and recommend corrective actions\n<\/li>\n<li>\nParticipate in client meetings and occasional field visits as needed\n<\/li>\n<\/ul>\n<h2>Required Qualifications<\/h2>\n<ul>\n<li>\n7+ years of experience working with LiDAR technologies, geospatial analysis, or related surveying\/GIS disciplines\n<\/li>\n<li>\nStrong working knowledge of GIS and CAD platforms, including:\n<ul>\n<li>\nArcGIS\n<\/li>\n<li>\nAutoCAD\n<\/li>\n<li>\nCivil 3D\n<\/li>\n<li>\nOther relevant geospatial processing software\n<\/li>\n<\/ul>\n<\/li>\n<li>\nExperience reviewing and interpreting point cloud datasets\n<\/li>\n<li>\nUnderstanding of LiDAR processing workflows, including classification, noise reduction, and data refinement\n<\/li>\n<li>\nExcellent written and verbal communication skills\n<\/li>\n<li>\nStrong technical writing ability with experience creating SOPs, documentation, or workflow guides\n<\/li>\n<li>\nAbility to manage multiple projects and priorities in a remote work environment\n<\/li>\n<li>\nHigh attention to detail and analytical problem-solving skills\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\nExperience supporting telecom, utility, or infrastructure projects\n<\/li>\n<li>\nFamiliarity with drone-based surveying and photogrammetry workflows\n<\/li>\n<li>\nExperience working with mobile mapping systems and terrestrial scanning technologies\n<\/li>\n<li>\nKnowledge of FAA drone operations or remote sensing technologies\n<\/li>\n<li>\nPrior experience interacting directly with clients or external stakeholders\n<\/li>\n<\/ul>\n<h2>Work Environment &amp; Travel<\/h2>\n<ul>\n<li>\nFully remote position with flexible collaboration across distributed teams\n<\/li>\n<li>\nUp to 20% travel may be required for client meetings, project coordination, training, or field support\n<\/li>\n<\/ul>\n<h2>Why Join Our Client?<\/h2>\n<ul>\n<li>\nOpportunity to work with cutting-edge LiDAR and geospatial technologies\n<\/li>\n<li>\nExposure to large-scale infrastructure and telecom projects\n<\/li>\n<li>\nCollaborative and innovation-focused team environment\n<\/li>\n<li>\nCareer growth opportunities within a rapidly evolving technical field\n<\/li>\n<li>\nAbility to make a direct impact on operational excellence and project success<\/li><\/ul>","post_title":"LiDAR Subject Matter Expert","post_link":"https:\/\/turnerstaffing.com\/position\/lidar-subject-matter-expert\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"San Antonio","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"San Antonio, TX","%education%":"Unspecified","%department%":"TSG","%description%":"<h2>Position Overview<\/h2>\n<p>Our client is seeking a highly motivated and detail-oriented LiDAR Subject Matter Expert (SME) to support telecom and infrastructure projects through advanced geospatial data analysis and technical guidance. This role is ideal for a candidate with strong experience in LiDAR processing, GIS platforms, and point cloud analysis who thrives in a collaborative, fast-paced environment.<\/p>\n<p>The LiDAR SME will serve as a technical resource responsible for reviewing terrestrial, aerial, and mobile LiDAR collection data gathered by field survey and drone pilot teams. This individual will evaluate deliverables for quality, accuracy, and usability while providing actionable feedback and recommendations to both internal stakeholders and end customers regarding project logistics, collection optimization, and workflow improvements.<\/p>\n<p>The ideal candidate combines technical expertise with excellent communication and documentation skills, helping establish best practices, create SOPs, and support continuous improvement initiatives across the organization.<\/p>\n<h2>Key Responsibilities<\/h2>\n<ul>\n<li>\nReview and analyze LiDAR collection datasets from terrestrial, aerial, and mobile platforms\n<\/li>\n<li>\nPerform quality assurance and quality control (QA\/QC) on point cloud data and geospatial deliverables\n<\/li>\n<li>\nApply techniques such as noise reduction, point cloud clarification, classification, and data refinement\n<\/li>\n<li>\nCollaborate with survey crews, drone pilots, GIS specialists, and project managers to improve collection workflows and project execution\n<\/li>\n<li>\nProvide technical feedback and recommendations to customers regarding telecom project logistics, data quality, and operational efficiencies\n<\/li>\n<li>\nInterpret and validate geospatial data using platforms such as ArcGIS, AutoCAD\/Civil 3D, and related GIS\/CAD tools\n<\/li>\n<li>\nDevelop and maintain SOPs, technical documentation, workflow guides, and training materials\n<\/li>\n<li>\nSupport process standardization and continuous improvement initiatives across LiDAR operations\n<\/li>\n<li>\nAssist with troubleshooting data collection or processing issues and recommend corrective actions\n<\/li>\n<li>\nParticipate in client meetings and occasional field visits as needed\n<\/li>\n<\/ul>\n<h2>Required Qualifications<\/h2>\n<ul>\n<li>\n7+ years of experience working with LiDAR technologies, geospatial analysis, or related surveying\/GIS disciplines\n<\/li>\n<li>\nStrong working knowledge of GIS and CAD platforms, including:\n<ul>\n<li>\nArcGIS\n<\/li>\n<li>\nAutoCAD\n<\/li>\n<li>\nCivil 3D\n<\/li>\n<li>\nOther relevant geospatial processing software\n<\/li>\n<\/ul>\n<\/li>\n<li>\nExperience reviewing and interpreting point cloud datasets\n<\/li>\n<li>\nUnderstanding of LiDAR processing workflows, including classification, noise reduction, and data refinement\n<\/li>\n<li>\nExcellent written and verbal communication skills\n<\/li>\n<li>\nStrong technical writing ability with experience creating SOPs, documentation, or workflow guides\n<\/li>\n<li>\nAbility to manage multiple projects and priorities in a remote work environment\n<\/li>\n<li>\nHigh attention to detail and analytical problem-solving skills\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\nExperience supporting telecom, utility, or infrastructure projects\n<\/li>\n<li>\nFamiliarity with drone-based surveying and photogrammetry workflows\n<\/li>\n<li>\nExperience working with mobile mapping systems and terrestrial scanning technologies\n<\/li>\n<li>\nKnowledge of FAA drone operations or remote sensing technologies\n<\/li>\n<li>\nPrior experience interacting directly with clients or external stakeholders\n<\/li>\n<\/ul>\n<h2>Work Environment &amp; Travel<\/h2>\n<ul>\n<li>\nFully remote position with flexible collaboration across distributed teams\n<\/li>\n<li>\nUp to 20% travel may be required for client meetings, project coordination, training, or field support\n<\/li>\n<\/ul>\n<h2>Why Join Our Client?<\/h2>\n<ul>\n<li>\nOpportunity to work with cutting-edge LiDAR and geospatial technologies\n<\/li>\n<li>\nExposure to large-scale infrastructure and telecom projects\n<\/li>\n<li>\nCollaborative and innovation-focused team environment\n<\/li>\n<li>\nCareer growth opportunities within a rapidly evolving technical field\n<\/li>\n<li>\nAbility to make a direct impact on operational excellence and project success<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/422b238907d9-lidar-subject-matter-expert","%breezy_id%":"422b238907d9","%breezy_friendly_id%":"422b238907d9-lidar-subject-matter-expert","%breezy_created_date%":"2026-05-13T14:00:17.836Z","%breezy_updated_date%":"2026-05-22T13:15:55.976Z","%_wpgmp_location_city%":"San Antonio","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"San Antonio, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.4251905","%_wpgmp_metabox_longitude%":"-98.4945922","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"258"}},"id":3617,"infowindow_disable":false},{"source":"post","title":"Regional EHS Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Regional EHS Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a highly experienced Regional EHS Supervisor to provide leadership and strategic oversight of environmental, health,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/regional-ehs-supervisor\/\" name=\"Regional EHS Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a highly experienced Regional EHS Supervisor to provide leadership and strategic oversight of environmental, health,&hellip;","address":"Midland, TXUnited States","location":{"lat":"31.9995797","city":"Midland","state":"TX","country":"United States","lng":"-102.0756701","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/regional-ehs-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a highly experienced Regional EHS Supervisor to provide leadership and strategic oversight of environmental, health,&hellip;","post_content":"<p>Turner Staffing Group is seeking a highly experienced <strong>Regional EHS Supervisor<\/strong> to provide leadership and strategic oversight of environmental, health, and safety programs across multiple operations in West Texas.<\/p><p>This role is designed for a senior EHS leader who can balance <strong>compliance, leadership, and operational partnership<\/strong> while driving consistency and performance across sites.<\/p><p><strong><\/strong><strong><strong>Schedule<\/strong><\/strong><\/p><ul><li>Monday through Friday <\/li><li>On-call availability required <\/li><li>Travel between sites as needed <\/li><\/ul><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>The Regional EHS Supervisor will lead EHS strategy, compliance, and performance across multiple operations. This role will oversee site-level EHS personnel, including <strong>EHS Coordinators and Supervisors<\/strong>, and ensure consistent implementation of safety programs and regulatory compliance.<\/p><p>The position requires both <strong>strategic leadership and strong field engagement<\/strong>, with regular presence at operating sites.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li>Provide <strong>regional leadership<\/strong> for EHS programs and initiatives <\/li><li>Ensure consistent compliance with <strong>MSHA and state environmental regulations (TCEQ)<\/strong> <\/li><li>Oversee and mentor site-level EHS staff <\/li><li>Drive standardization of safety programs and best practices across operations <\/li><li>Lead audits, inspections, and incident investigations <\/li><li>Collaborate with operations leadership to align safety and production goals <\/li><li>Track and report EHS performance metrics and continuous improvement initiatives <\/li><li>Serve as a liaison with regulatory agencies and corporate stakeholders <\/li><li>Support training, development, and succession planning for EHS teams<\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><strong>10&ndash;15+ years of EHS experience<\/strong> in mining, industrial, or heavy industry environments <\/li><li>Strong knowledge of <strong>MSHA regulations and compliance<\/strong> <\/li><li>Experience with <strong>state environmental regulations (TCEQ preferred)<\/strong> <\/li><li>Proven experience leading EHS programs across multiple sites or operations <\/li><li>Strong leadership, communication, and organizational skills <\/li><li>Ability to influence at all levels of the organization <\/li><li>Valid driver&rsquo;s license<\/li><li>Authorized to workin the US without work visa sponsorship<\/li><\/ul><p><strong><strong>Ideal Candidate<\/strong><\/strong><\/p><ul><li>Strong believer that <strong>all incidents are preventable<\/strong> <\/li><li>Able to lead with influence rather than enforcement alone <\/li><li>Comfortable balancing compliance with operational realities <\/li><li>Strategic thinker with strong execution capability <\/li><li>Experienced in building and developing high-performing EHS teams <\/li><\/ul><p><strong><strong>Why This Role<\/strong><\/strong><\/p><ul><li>Senior leadership opportunity with regional impact <\/li><li>Competitive compensation, bonus, and relocation support <\/li><li>Opportunity to shape EHS strategy and performance across multiple operations <\/li><li>High visibility with leadership and operational teams <\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are a seasoned EHS leader ready to take ownership of regional safety performance and drive meaningful impact, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","post_title":"Regional EHS Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/regional-ehs-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Midland","%location_state_id%":"TX","%location_city_state%":"Midland, TX","%description%":"<p>Turner Staffing Group is seeking a highly experienced <strong>Regional EHS Supervisor<\/strong> to provide leadership and strategic oversight of environmental, health, and safety programs across multiple operations in West Texas.<\/p><p>This role is designed for a senior EHS leader who can balance <strong>compliance, leadership, and operational partnership<\/strong> while driving consistency and performance across sites.<\/p><p><strong><\/strong><strong><strong>Schedule<\/strong><\/strong><\/p><ul><li>Monday through Friday <\/li><li>On-call availability required <\/li><li>Travel between sites as needed <\/li><\/ul><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>The Regional EHS Supervisor will lead EHS strategy, compliance, and performance across multiple operations. This role will oversee site-level EHS personnel, including <strong>EHS Coordinators and Supervisors<\/strong>, and ensure consistent implementation of safety programs and regulatory compliance.<\/p><p>The position requires both <strong>strategic leadership and strong field engagement<\/strong>, with regular presence at operating sites.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li>Provide <strong>regional leadership<\/strong> for EHS programs and initiatives <\/li><li>Ensure consistent compliance with <strong>MSHA and state environmental regulations (TCEQ)<\/strong> <\/li><li>Oversee and mentor site-level EHS staff <\/li><li>Drive standardization of safety programs and best practices across operations <\/li><li>Lead audits, inspections, and incident investigations <\/li><li>Collaborate with operations leadership to align safety and production goals <\/li><li>Track and report EHS performance metrics and continuous improvement initiatives <\/li><li>Serve as a liaison with regulatory agencies and corporate stakeholders <\/li><li>Support training, development, and succession planning for EHS teams<\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><strong>10&ndash;15+ years of EHS experience<\/strong> in mining, industrial, or heavy industry environments <\/li><li>Strong knowledge of <strong>MSHA regulations and compliance<\/strong> <\/li><li>Experience with <strong>state environmental regulations (TCEQ preferred)<\/strong> <\/li><li>Proven experience leading EHS programs across multiple sites or operations <\/li><li>Strong leadership, communication, and organizational skills <\/li><li>Ability to influence at all levels of the organization <\/li><li>Valid driver&rsquo;s license<\/li><li>Authorized to workin the US without work visa sponsorship<\/li><\/ul><p><strong><strong>Ideal Candidate<\/strong><\/strong><\/p><ul><li>Strong believer that <strong>all incidents are preventable<\/strong> <\/li><li>Able to lead with influence rather than enforcement alone <\/li><li>Comfortable balancing compliance with operational realities <\/li><li>Strategic thinker with strong execution capability <\/li><li>Experienced in building and developing high-performing EHS teams <\/li><\/ul><p><strong><strong>Why This Role<\/strong><\/strong><\/p><ul><li>Senior leadership opportunity with regional impact <\/li><li>Competitive compensation, bonus, and relocation support <\/li><li>Opportunity to shape EHS strategy and performance across multiple operations <\/li><li>High visibility with leadership and operational teams <\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are a seasoned EHS leader ready to take ownership of regional safety performance and drive meaningful impact, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/9pmjnjer8u9kgjz4tas6ebfkpe","%crelate_id%":"9pmjnjer8u9kgjz4tas6ebfkpe","%crelate_created_date%":"2026-03-23T17:32:56.47Z","%crelate_updated_date%":"2026-06-08T13:49:10.28Z","%_wpgmp_location_city%":"Midland","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Midland, TXUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9995797","%_wpgmp_metabox_longitude%":"-102.0756701","%rank_math_internal_links_processed%":"1"}},"id":3614,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator- Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator- Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Summary The traveling&nbsp;Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-7\/\" name=\"Heavy Equipment Operator- Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Summary The traveling&nbsp;Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining&hellip;","address":"Las Vegas, NV, USA","location":{"lat":"36.171563","city":"Las Vegas","state":"NV","country":"United States","lng":"-115.1391009","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-7\/","zoom":19,"extra_fields":{"post_excerpt":"Position Summary The traveling&nbsp;Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining&hellip;","post_content":"<h3>Position Summary<\/h3>\n<p>The traveling&nbsp;Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining operations. Equipment may include haul trucks, loaders, excavators, water trucks, dozers, graders, and other production support machinery. Operators play a critical role in maintaining production goals while adhering to strict safety and operational standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nOperate heavy mobile equipment in a safe, efficient, and productive manner\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections and complete required documentation\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions promptly\n<\/li>\n<li>\nFollow mine site safety procedures, policies, and MSHA regulations at all times\n<\/li>\n<li>\nWork closely with supervisors, dispatch, and other team members to meet daily production targets\n<\/li>\n<li>\nMaintain clean and orderly equipment cabs and work areas\n<\/li>\n<li>\nAssist with general mine site tasks as needed to support operations\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating heavy equipment in mining, quarry, construction, or similar industrial environments preferred\n<\/li>\n<li>\nAbility to safely operate one or more types of mobile equipment such as haul trucks, loaders, excavators, or dozers\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong understanding of equipment safety protocols and hazard awareness\n<\/li>\n<li>\nAbility to work in varying weather and site conditions\n<\/li>\n<li>\nReliable transportation and strong attendance record\n<\/li>\n<li>\nAbility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to sit, stand, climb, bend, and walk for extended periods\n<\/li>\n<li>\nAbility to climb in and out of heavy equipment multiple times per shift\n<\/li>\n<li>\nMust be able to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to work in dusty, rugged outdoor environments<\/li><\/ul>","post_title":"Heavy Equipment Operator- Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Las Vegas","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Las Vegas, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>Position Summary<\/h3>\n<p>The traveling&nbsp;Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining operations. Equipment may include haul trucks, loaders, excavators, water trucks, dozers, graders, and other production support machinery. Operators play a critical role in maintaining production goals while adhering to strict safety and operational standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nOperate heavy mobile equipment in a safe, efficient, and productive manner\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections and complete required documentation\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions promptly\n<\/li>\n<li>\nFollow mine site safety procedures, policies, and MSHA regulations at all times\n<\/li>\n<li>\nWork closely with supervisors, dispatch, and other team members to meet daily production targets\n<\/li>\n<li>\nMaintain clean and orderly equipment cabs and work areas\n<\/li>\n<li>\nAssist with general mine site tasks as needed to support operations\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating heavy equipment in mining, quarry, construction, or similar industrial environments preferred\n<\/li>\n<li>\nAbility to safely operate one or more types of mobile equipment such as haul trucks, loaders, excavators, or dozers\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong understanding of equipment safety protocols and hazard awareness\n<\/li>\n<li>\nAbility to work in varying weather and site conditions\n<\/li>\n<li>\nReliable transportation and strong attendance record\n<\/li>\n<li>\nAbility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to sit, stand, climb, bend, and walk for extended periods\n<\/li>\n<li>\nAbility to climb in and out of heavy equipment multiple times per shift\n<\/li>\n<li>\nMust be able to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to work in dusty, rugged outdoor environments<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/facfb97dddcb-heavy-equipment-operator-traveling","%breezy_id%":"facfb97dddcb","%breezy_friendly_id%":"facfb97dddcb-heavy-equipment-operator-traveling","%breezy_created_date%":"2026-05-11T16:28:16.191Z","%breezy_updated_date%":"2026-05-18T20:49:49.961Z","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Las Vegas, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.171563","%_wpgmp_metabox_longitude%":"-115.1391009","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"257"}},"id":3608,"infowindow_disable":false},{"source":"post","title":"Fuel\/Lube Technician &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Fuel\/Lube Technician &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Fuel\/Lube Technician \u2013 Mine Site Position Summary We are seeking a dependable and safety-focused Fuel\/Lube Technician to support daily mining&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-traveling\/\" name=\"Fuel\/Lube Technician &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Fuel\/Lube Technician \u2013 Mine Site Position Summary We are seeking a dependable and safety-focused Fuel\/Lube Technician to support daily mining&hellip;","address":"Las Vegas, NV, USA","location":{"lat":"36.171563","city":"Las Vegas","state":"NV","country":"United States","lng":"-115.1391009","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"Fuel\/Lube Technician \u2013 Mine Site Position Summary We are seeking a dependable and safety-focused Fuel\/Lube Technician to support daily mining&hellip;","post_content":"<h1>Fuel\/Lube Technician \u2013 Mine Site<\/h1>\n<h2>Position Summary<\/h2>\n<p>We are seeking a dependable and safety-focused Fuel\/Lube Technician to support daily mining operations by fueling, lubricating, and performing preventative maintenance services on heavy equipment at an active mine site. This position plays a key role in maintaining equipment uptime and ensuring safe, efficient operations.<\/p>\n<p>The ideal candidate will have experience servicing heavy equipment in mining, construction, quarry, or similar heavy industrial environments.<\/p>\n<h2>Schedule<\/h2>\n<ul>\n<li>\n12-hour shifts\n<\/li>\n<li>\nDay and night shift opportunities may be available\n<\/li>\n<li>\nOvertime may be required based on production needs and weather conditions\n<\/li>\n<\/ul>\n<h2>Responsibilities<\/h2>\n<ul>\n<li>\nFuel, grease, and lubricate heavy mining and construction equipment\n<\/li>\n<li>\nPerform daily preventative maintenance services and fluid checks\n<\/li>\n<li>\nInspect equipment for leaks, damage, and maintenance concerns\n<\/li>\n<li>\nMaintain accurate service and fuel records\n<\/li>\n<li>\nSafely operate service trucks and fuel\/lube equipment\n<\/li>\n<li>\nFollow all mine site safety procedures and MSHA regulations\n<\/li>\n<li>\nCommunicate maintenance issues to supervisors and mechanics\n<\/li>\n<li>\nKeep work areas clean and organized\n<\/li>\n<\/ul>\n<h2>Equipment Serviced<\/h2>\n<ul>\n<li>\n6015 Excavator\n<\/li>\n<li>\n670 Excavator\n<\/li>\n<li>\n349 Excavator\n<\/li>\n<li>\n336 Excavator\n<\/li>\n<li>\nD10 Dozer\n<\/li>\n<li>\nD8 Dozer\n<\/li>\n<li>\nD6 Dozer\n<\/li>\n<li>\n100T Haul Truck\n<\/li>\n<li>\n40T Articulated Haul Truck\n<\/li>\n<li>\n14M Grader\n<\/li>\n<li>\nArticulated Water Truck\n<\/li>\n<li>\n950 Loader\n<\/li>\n<\/ul>\n<h2>Qualifications<\/h2>\n<ul>\n<li>\nPrevious fuel\/lube or preventative maintenance experience preferred\n<\/li>\n<li>\nExperience working around heavy equipment required\n<\/li>\n<li>\nMining, quarry, or construction experience strongly preferred\n<\/li>\n<li>\nAbility to work 12-hour shifts in outdoor conditions\n<\/li>\n<li>\nStrong attention to safety and detail\n<\/li>\n<li>\nAbility to lift, climb, bend, and work in physically demanding environments\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification preferred but not required\n<\/li>\n<\/ul>\n<h2>Work Environment<\/h2>\n<ul>\n<li>\nActive surface mine environment\n<\/li>\n<li>\nExposure to dust, mud, noise, vibration, and changing weather conditions\n<\/li>\n<li>\nRequires standing, walking, climbing, and working around moving equipment<\/li><\/ul>","post_title":"Fuel\/Lube Technician &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Las Vegas","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Las Vegas, NV","%education%":"","%department%":"TSG","%description%":"<h1>Fuel\/Lube Technician \u2013 Mine Site<\/h1>\n<h2>Position Summary<\/h2>\n<p>We are seeking a dependable and safety-focused Fuel\/Lube Technician to support daily mining operations by fueling, lubricating, and performing preventative maintenance services on heavy equipment at an active mine site. This position plays a key role in maintaining equipment uptime and ensuring safe, efficient operations.<\/p>\n<p>The ideal candidate will have experience servicing heavy equipment in mining, construction, quarry, or similar heavy industrial environments.<\/p>\n<h2>Schedule<\/h2>\n<ul>\n<li>\n12-hour shifts\n<\/li>\n<li>\nDay and night shift opportunities may be available\n<\/li>\n<li>\nOvertime may be required based on production needs and weather conditions\n<\/li>\n<\/ul>\n<h2>Responsibilities<\/h2>\n<ul>\n<li>\nFuel, grease, and lubricate heavy mining and construction equipment\n<\/li>\n<li>\nPerform daily preventative maintenance services and fluid checks\n<\/li>\n<li>\nInspect equipment for leaks, damage, and maintenance concerns\n<\/li>\n<li>\nMaintain accurate service and fuel records\n<\/li>\n<li>\nSafely operate service trucks and fuel\/lube equipment\n<\/li>\n<li>\nFollow all mine site safety procedures and MSHA regulations\n<\/li>\n<li>\nCommunicate maintenance issues to supervisors and mechanics\n<\/li>\n<li>\nKeep work areas clean and organized\n<\/li>\n<\/ul>\n<h2>Equipment Serviced<\/h2>\n<ul>\n<li>\n6015 Excavator\n<\/li>\n<li>\n670 Excavator\n<\/li>\n<li>\n349 Excavator\n<\/li>\n<li>\n336 Excavator\n<\/li>\n<li>\nD10 Dozer\n<\/li>\n<li>\nD8 Dozer\n<\/li>\n<li>\nD6 Dozer\n<\/li>\n<li>\n100T Haul Truck\n<\/li>\n<li>\n40T Articulated Haul Truck\n<\/li>\n<li>\n14M Grader\n<\/li>\n<li>\nArticulated Water Truck\n<\/li>\n<li>\n950 Loader\n<\/li>\n<\/ul>\n<h2>Qualifications<\/h2>\n<ul>\n<li>\nPrevious fuel\/lube or preventative maintenance experience preferred\n<\/li>\n<li>\nExperience working around heavy equipment required\n<\/li>\n<li>\nMining, quarry, or construction experience strongly preferred\n<\/li>\n<li>\nAbility to work 12-hour shifts in outdoor conditions\n<\/li>\n<li>\nStrong attention to safety and detail\n<\/li>\n<li>\nAbility to lift, climb, bend, and work in physically demanding environments\n<\/li>\n<li>\nValid driver\u2019s license required\n<\/li>\n<li>\nMSHA certification preferred but not required\n<\/li>\n<\/ul>\n<h2>Work Environment<\/h2>\n<ul>\n<li>\nActive surface mine environment\n<\/li>\n<li>\nExposure to dust, mud, noise, vibration, and changing weather conditions\n<\/li>\n<li>\nRequires standing, walking, climbing, and working around moving equipment<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/879c208044fa-fuel-lube-technician-traveling","%breezy_id%":"879c208044fa","%breezy_friendly_id%":"879c208044fa-fuel-lube-technician-traveling","%breezy_created_date%":"2026-05-08T21:44:37.406Z","%breezy_updated_date%":"2026-05-12T13:14:39.755Z","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Las Vegas, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.171563","%_wpgmp_metabox_longitude%":"-115.1391009","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"256"}},"id":3604,"infowindow_disable":false},{"source":"post","title":"Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based&hellip;","address":"Fairbanks, AKUnited States","location":{"lat":"64.8400511","city":"Fairbanks","state":"AK","country":"United States","lng":"-147.7199756","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based&hellip;","post_content":"<p style=\"color:#374151\">We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p><p style=\"color:#374151\"><span style=\"color:var(--tw-prose-bold)\"><strong>Responsibilities:<\/strong><\/span><\/p><ol><li><p><span style=\"color:var(--tw-prose-bold)\">Drill Core Logging and Sampling:<\/span><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Digital Data Entry:<\/span><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Collation and Interpretation of Data:<\/span><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Liaising with Drill Contractors and Other Geologists:<\/span><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li>Other duties as assigned.<\/li><\/ol><p style=\"color:#374151\"><span style=\"color:var(--tw-prose-bold)\"><strong>Qualifications:<\/strong><\/span><\/p><ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling preferred.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<br \/><\/li><\/ul><p><span style=\"color:#222222\">Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/span><\/p>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Fairbanks","%location_state_id%":"AK","%location_city_state%":"Fairbanks, AK","%description%":"<p style=\"color:#374151;\">We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p><p style=\"color:#374151;\"><span style=\"color:var(--tw-prose-bold);\"><strong>Responsibilities:<\/strong><\/span><\/p><ol><li><p><span style=\"color:var(--tw-prose-bold);\">Drill Core Logging and Sampling:<\/span><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Digital Data Entry:<\/span><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Collation and Interpretation of Data:<\/span><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Liaising with Drill Contractors and Other Geologists:<\/span><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li>Other duties as assigned.<\/li><\/ol><p style=\"color:#374151;\"><span style=\"color:var(--tw-prose-bold);\"><strong>Qualifications:<\/strong><\/span><\/p><ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling preferred.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<br \/><\/li><\/ul><p><span style=\"color:#222222;\">Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/span><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/8zgyz5bmygko48ywj8sxswfxga","%crelate_id%":"8zgyz5bmygko48ywj8sxswfxga","%crelate_created_date%":"2026-05-06T12:34:55.5Z","%crelate_updated_date%":"2026-06-11T11:22:44.16Z","%_wpgmp_location_city%":"Fairbanks","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairbanks, AKUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"64.8400511","%_wpgmp_metabox_longitude%":"-147.7199756","%rank_math_internal_links_processed%":"1"}},"id":3601,"infowindow_disable":false},{"source":"post","title":"Water Truck Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Water Truck Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About the Opportunity Turner Staffing Group is seeking a Water Truck Operator to support surface operations in Nevada.&nbsp; This position&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/water-truck-operator-3\/\" name=\"Water Truck Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About the Opportunity Turner Staffing Group is seeking a Water Truck Operator to support surface operations in Nevada.&nbsp; This position&hellip;","address":"Winnemucca, NV, USA","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/water-truck-operator-3\/","zoom":19,"extra_fields":{"post_excerpt":"About the Opportunity Turner Staffing Group is seeking a Water Truck Operator to support surface operations in Nevada.&nbsp; This position&hellip;","post_content":"<h3>About the Opportunity<\/h3>\n<p>Turner Staffing Group is seeking a <strong>Water Truck Operator<\/strong> to support surface operations in Nevada.&nbsp;<\/p>\n<p>This position is ideal for individuals who prioritize safety, take pride in equipment operation, and can work effectively in dynamic site conditions.<\/p>\n<h3>Key Responsibilities<\/h3>\n<p>As a Water Truck Operator, you will:<\/p>\n<ul>\n<li>\nSafely operate an 8,000-gallon water truck in accordance with site rules and manufacturer guidelines\n<\/li>\n<li>\nPerform and document pre-operational inspections (fluids, tires, brakes, lights, articulation joint, etc.)\n<\/li>\n<li>\nMaintain full control of the vehicle across varying road and weather conditions\n<\/li>\n<li>\nEnsure safe loading, transport, and controlled discharge of water\n<\/li>\n<li>\nMonitor tank systems, including hoses, valves, and pumps, for proper function\n<\/li>\n<li>\nCommunicate effectively using site radio and follow all traffic protocols\n<\/li>\n<li>\nReport hazards, incidents, and mechanical issues immediately\n<\/li>\n<li>\nComplete all required logs, reports, and documentation\n<\/li>\n<\/ul>\n<h3>Work Activities<\/h3>\n<ul>\n<li>\nConduct daily equipment inspections and post-operation checks\n<\/li>\n<li>\nVerify system integrity (tank, valves, pump functionality)\n<\/li>\n<li>\nOperate only on approved haul routes and maintain safe speeds\n<\/li>\n<li>\nMaintain safe following distances and situational awareness\n<\/li>\n<li>\nPosition equipment safely for water discharge operations\n<\/li>\n<li>\nPrevent spills, overflows, erosion, or unsafe discharge conditions\n<\/li>\n<li>\nFollow proper parking, shutdown, and lockout procedures when required\n<\/li>\n<\/ul>\n<h3>Equipment Operated<\/h3>\n<ul>\n<li>\nVolvo A40G Water Truck (8,000-gallon capacity)\n<\/li>\n<li>\nOnboard pumping and spray systems\n<\/li>\n<li>\nSite communication systems (radio)\n<\/li>\n<li>\nStandard safety equipment (fire extinguisher, spill kit, emergency supplies)\n<\/li>\n<\/ul>\n<h3>Safety Expectations<\/h3>\n<p>Safety is a core value at Turner Staffing Group. All operators are expected to:<\/p>\n<ul>\n<li>\nComply with all site-specific safety policies and MSHA regulations\n<\/li>\n<li>\nWear required PPE at all times\n<\/li>\n<li>\nMaintain awareness of surroundings (personnel, equipment, terrain)\n<\/li>\n<li>\nFollow traffic management and right-of-way rules\n<\/li>\n<li>\nMonitor ground conditions, including slopes and soft areas\n<\/li>\n<li>\nPrevent water-related hazards such as spills, icing, or runoff\n<\/li>\n<li>\nAdhere to fatigue management and work\/rest schedules\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating water trucks or similar heavy equipment preferred\n<\/li>\n<li>\nStrong commitment to safety and operational excellence\n<\/li>\n<li>\nAbility to perform inspections and basic equipment checks\n<\/li>\n<li>\nEffective communication skills and ability to follow site procedures\n<\/li>\n<li>\nMSHA certification (or willingness to obtain prior to start)<\/li><\/ul>","post_title":"Water Truck Operator","post_link":"https:\/\/turnerstaffing.com\/position\/water-truck-operator-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Temporary","%experience%":"Associate","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Winnemucca, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About the Opportunity<\/h3>\n<p>Turner Staffing Group is seeking a <strong>Water Truck Operator<\/strong> to support surface operations in Nevada.&nbsp;<\/p>\n<p>This position is ideal for individuals who prioritize safety, take pride in equipment operation, and can work effectively in dynamic site conditions.<\/p>\n<h3>Key Responsibilities<\/h3>\n<p>As a Water Truck Operator, you will:<\/p>\n<ul>\n<li>\nSafely operate an 8,000-gallon water truck in accordance with site rules and manufacturer guidelines\n<\/li>\n<li>\nPerform and document pre-operational inspections (fluids, tires, brakes, lights, articulation joint, etc.)\n<\/li>\n<li>\nMaintain full control of the vehicle across varying road and weather conditions\n<\/li>\n<li>\nEnsure safe loading, transport, and controlled discharge of water\n<\/li>\n<li>\nMonitor tank systems, including hoses, valves, and pumps, for proper function\n<\/li>\n<li>\nCommunicate effectively using site radio and follow all traffic protocols\n<\/li>\n<li>\nReport hazards, incidents, and mechanical issues immediately\n<\/li>\n<li>\nComplete all required logs, reports, and documentation\n<\/li>\n<\/ul>\n<h3>Work Activities<\/h3>\n<ul>\n<li>\nConduct daily equipment inspections and post-operation checks\n<\/li>\n<li>\nVerify system integrity (tank, valves, pump functionality)\n<\/li>\n<li>\nOperate only on approved haul routes and maintain safe speeds\n<\/li>\n<li>\nMaintain safe following distances and situational awareness\n<\/li>\n<li>\nPosition equipment safely for water discharge operations\n<\/li>\n<li>\nPrevent spills, overflows, erosion, or unsafe discharge conditions\n<\/li>\n<li>\nFollow proper parking, shutdown, and lockout procedures when required\n<\/li>\n<\/ul>\n<h3>Equipment Operated<\/h3>\n<ul>\n<li>\nVolvo A40G Water Truck (8,000-gallon capacity)\n<\/li>\n<li>\nOnboard pumping and spray systems\n<\/li>\n<li>\nSite communication systems (radio)\n<\/li>\n<li>\nStandard safety equipment (fire extinguisher, spill kit, emergency supplies)\n<\/li>\n<\/ul>\n<h3>Safety Expectations<\/h3>\n<p>Safety is a core value at Turner Staffing Group. All operators are expected to:<\/p>\n<ul>\n<li>\nComply with all site-specific safety policies and MSHA regulations\n<\/li>\n<li>\nWear required PPE at all times\n<\/li>\n<li>\nMaintain awareness of surroundings (personnel, equipment, terrain)\n<\/li>\n<li>\nFollow traffic management and right-of-way rules\n<\/li>\n<li>\nMonitor ground conditions, including slopes and soft areas\n<\/li>\n<li>\nPrevent water-related hazards such as spills, icing, or runoff\n<\/li>\n<li>\nAdhere to fatigue management and work\/rest schedules\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating water trucks or similar heavy equipment preferred\n<\/li>\n<li>\nStrong commitment to safety and operational excellence\n<\/li>\n<li>\nAbility to perform inspections and basic equipment checks\n<\/li>\n<li>\nEffective communication skills and ability to follow site procedures\n<\/li>\n<li>\nMSHA certification (or willingness to obtain prior to start)<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a669b020fdb7-water-truck-operator","%breezy_id%":"a669b020fdb7","%breezy_friendly_id%":"a669b020fdb7-water-truck-operator","%breezy_created_date%":"2026-05-06T15:24:35.281Z","%breezy_updated_date%":"2026-05-18T20:53:13.104Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"255"}},"id":3593,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are actively seeking a Excavator Operator to work with us in the Charlotte, NC area. Our client works on&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are actively seeking a Excavator Operator to work with us in the Charlotte, NC area. Our client works on&hellip;","address":"Charlotte, NC, USA","location":{"lat":"35.2270768","city":"Charlotte","state":"NC","country":"United States","lng":"-80.8408933","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator\/","zoom":19,"extra_fields":{"post_excerpt":"We are actively seeking a Excavator Operator to work with us in the Charlotte, NC area. Our client works on&hellip;","post_content":"<p>We are actively seeking a Excavator Operator to work with us in the Charlotte, NC area. Our client works on projects usually within a 2 hour radius of Yadkinville, NC.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors and teammates<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Participate in necessary training sessions.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators<\/li><li>GPS System experience required&nbsp;<\/li><li>Ability to read and understand grade stakes.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charlotte","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Charlotte, NC","%education%":"","%department%":"TSG","%description%":"<p>We are actively seeking a Excavator Operator to work with us in the Charlotte, NC area. Our client works on projects usually within a 2 hour radius of Yadkinville, NC.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors and teammates<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Participate in necessary training sessions.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators<\/li><li>GPS System experience required&nbsp;<\/li><li>Ability to read and understand grade stakes.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/1c988197c1ae-excavator-operator","%breezy_id%":"1c988197c1ae","%breezy_friendly_id%":"1c988197c1ae-excavator-operator","%breezy_created_date%":"2025-03-04T18:11:14.690Z","%breezy_updated_date%":"2026-05-21T16:03:42.201Z","%_wpgmp_location_city%":"Charlotte","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charlotte, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.2270768","%_wpgmp_metabox_longitude%":"-80.8408933","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"243"}},"id":3591,"infowindow_disable":false},{"source":"post","title":"Water Truck Operator &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Water Truck Operator &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About the Opportunity Turner Staffing Group is seeking a Water Truck Operator to support surface operations in Nevada.&nbsp; This position&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/water-truck-operator-2\/\" name=\"Water Truck Operator &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About the Opportunity Turner Staffing Group is seeking a Water Truck Operator to support surface operations in Nevada.&nbsp; This position&hellip;","address":"Tonopah, NV, USA","location":{"lat":"38.069211","city":"Tonopah","state":"NV","country":"United States","lng":"-117.2305861","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/water-truck-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"About the Opportunity Turner Staffing Group is seeking a Water Truck Operator to support surface operations in Nevada.&nbsp; This position&hellip;","post_content":"<h3>About the Opportunity<\/h3>\n<p>Turner Staffing Group is seeking a <strong>Water Truck Operator<\/strong> to support surface operations in Nevada.&nbsp;<\/p>\n<p>This position is ideal for individuals who prioritize safety, take pride in equipment operation, and can work effectively in dynamic site conditions.<\/p>\n<h3>Key Responsibilities<\/h3>\n<p>As a Water Truck Operator, you will:<\/p>\n<ul>\n<li>\nSafely operate an 8,000-gallon water truck in accordance with site rules and manufacturer guidelines\n<\/li>\n<li>\nPerform and document pre-operational inspections (fluids, tires, brakes, lights, articulation joint, etc.)\n<\/li>\n<li>\nMaintain full control of the vehicle across varying road and weather conditions\n<\/li>\n<li>\nEnsure safe loading, transport, and controlled discharge of water\n<\/li>\n<li>\nMonitor tank systems, including hoses, valves, and pumps, for proper function\n<\/li>\n<li>\nCommunicate effectively using site radio and follow all traffic protocols\n<\/li>\n<li>\nReport hazards, incidents, and mechanical issues immediately\n<\/li>\n<li>\nComplete all required logs, reports, and documentation\n<\/li>\n<\/ul>\n<h3>Work Activities<\/h3>\n<ul>\n<li>\nConduct daily equipment inspections and post-operation checks\n<\/li>\n<li>\nVerify system integrity (tank, valves, pump functionality)\n<\/li>\n<li>\nOperate only on approved haul routes and maintain safe speeds\n<\/li>\n<li>\nMaintain safe following distances and situational awareness\n<\/li>\n<li>\nPosition equipment safely for water discharge operations\n<\/li>\n<li>\nPrevent spills, overflows, erosion, or unsafe discharge conditions\n<\/li>\n<li>\nFollow proper parking, shutdown, and lockout procedures when required\n<\/li>\n<\/ul>\n<h3>Equipment Operated<\/h3>\n<ul>\n<li>\nVolvo A40G Water Truck (8,000-gallon capacity)\n<\/li>\n<li>\nOnboard pumping and spray systems\n<\/li>\n<li>\nSite communication systems (radio)\n<\/li>\n<li>\nStandard safety equipment (fire extinguisher, spill kit, emergency supplies)\n<\/li>\n<\/ul>\n<h3>Safety Expectations<\/h3>\n<p>Safety is a core value at Turner Staffing Group. All operators are expected to:<\/p>\n<ul>\n<li>\nComply with all site-specific safety policies and MSHA regulations\n<\/li>\n<li>\nWear required PPE at all times\n<\/li>\n<li>\nMaintain awareness of surroundings (personnel, equipment, terrain)\n<\/li>\n<li>\nFollow traffic management and right-of-way rules\n<\/li>\n<li>\nMonitor ground conditions, including slopes and soft areas\n<\/li>\n<li>\nPrevent water-related hazards such as spills, icing, or runoff\n<\/li>\n<li>\nAdhere to fatigue management and work\/rest schedules\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating water trucks or similar heavy equipment preferred\n<\/li>\n<li>\nStrong commitment to safety and operational excellence\n<\/li>\n<li>\nAbility to perform inspections and basic equipment checks\n<\/li>\n<li>\nEffective communication skills and ability to follow site procedures\n<\/li>\n<li>\nMSHA certification (or willingness to obtain prior to start)<\/li><\/ul>","post_title":"Water Truck Operator &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/water-truck-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Temporary","%experience%":"Associate","%location_country%":"United States","%location_city%":"Tonopah","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Tonopah, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About the Opportunity<\/h3>\n<p>Turner Staffing Group is seeking a <strong>Water Truck Operator<\/strong> to support surface operations in Nevada.&nbsp;<\/p>\n<p>This position is ideal for individuals who prioritize safety, take pride in equipment operation, and can work effectively in dynamic site conditions.<\/p>\n<h3>Key Responsibilities<\/h3>\n<p>As a Water Truck Operator, you will:<\/p>\n<ul>\n<li>\nSafely operate an 8,000-gallon water truck in accordance with site rules and manufacturer guidelines\n<\/li>\n<li>\nPerform and document pre-operational inspections (fluids, tires, brakes, lights, articulation joint, etc.)\n<\/li>\n<li>\nMaintain full control of the vehicle across varying road and weather conditions\n<\/li>\n<li>\nEnsure safe loading, transport, and controlled discharge of water\n<\/li>\n<li>\nMonitor tank systems, including hoses, valves, and pumps, for proper function\n<\/li>\n<li>\nCommunicate effectively using site radio and follow all traffic protocols\n<\/li>\n<li>\nReport hazards, incidents, and mechanical issues immediately\n<\/li>\n<li>\nComplete all required logs, reports, and documentation\n<\/li>\n<\/ul>\n<h3>Work Activities<\/h3>\n<ul>\n<li>\nConduct daily equipment inspections and post-operation checks\n<\/li>\n<li>\nVerify system integrity (tank, valves, pump functionality)\n<\/li>\n<li>\nOperate only on approved haul routes and maintain safe speeds\n<\/li>\n<li>\nMaintain safe following distances and situational awareness\n<\/li>\n<li>\nPosition equipment safely for water discharge operations\n<\/li>\n<li>\nPrevent spills, overflows, erosion, or unsafe discharge conditions\n<\/li>\n<li>\nFollow proper parking, shutdown, and lockout procedures when required\n<\/li>\n<\/ul>\n<h3>Equipment Operated<\/h3>\n<ul>\n<li>\nVolvo A40G Water Truck (8,000-gallon capacity)\n<\/li>\n<li>\nOnboard pumping and spray systems\n<\/li>\n<li>\nSite communication systems (radio)\n<\/li>\n<li>\nStandard safety equipment (fire extinguisher, spill kit, emergency supplies)\n<\/li>\n<\/ul>\n<h3>Safety Expectations<\/h3>\n<p>Safety is a core value at Turner Staffing Group. All operators are expected to:<\/p>\n<ul>\n<li>\nComply with all site-specific safety policies and MSHA regulations\n<\/li>\n<li>\nWear required PPE at all times\n<\/li>\n<li>\nMaintain awareness of surroundings (personnel, equipment, terrain)\n<\/li>\n<li>\nFollow traffic management and right-of-way rules\n<\/li>\n<li>\nMonitor ground conditions, including slopes and soft areas\n<\/li>\n<li>\nPrevent water-related hazards such as spills, icing, or runoff\n<\/li>\n<li>\nAdhere to fatigue management and work\/rest schedules\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating water trucks or similar heavy equipment preferred\n<\/li>\n<li>\nStrong commitment to safety and operational excellence\n<\/li>\n<li>\nAbility to perform inspections and basic equipment checks\n<\/li>\n<li>\nEffective communication skills and ability to follow site procedures\n<\/li>\n<li>\nMSHA certification (or willingness to obtain prior to start)<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/10e429eb33dc-water-truck-operator-traveling","%breezy_id%":"10e429eb33dc","%breezy_friendly_id%":"10e429eb33dc-water-truck-operator-traveling","%breezy_created_date%":"2026-05-05T19:12:54.663Z","%breezy_updated_date%":"2026-05-19T15:43:07.988Z","%_wpgmp_location_city%":"Tonopah","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tonopah, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.069211","%_wpgmp_metabox_longitude%":"-117.2305861","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"254"}},"id":3589,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Heavy Equipment Mechanic (Mining Equipment) Schedule: 12-hour shifts&nbsp; Position Overview We are seeking an experienced Heavy Equipment Mechanic&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-traveling-3\/\" name=\"Heavy Equipment Mechanic &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Heavy Equipment Mechanic (Mining Equipment) Schedule: 12-hour shifts&nbsp; Position Overview We are seeking an experienced Heavy Equipment Mechanic&hellip;","address":"Winnemucca, NV, USA","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-traveling-3\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Heavy Equipment Mechanic (Mining Equipment) Schedule: 12-hour shifts&nbsp; Position Overview We are seeking an experienced Heavy Equipment Mechanic&hellip;","post_content":"<p><strong>Job Title:<\/strong> Heavy Equipment Mechanic (Mining Equipment)<br>\n<strong>Schedule:<\/strong> 12-hour shifts&nbsp;<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking an experienced <strong>Heavy Equipment Mechanic<\/strong> to join our team, responsible for maintaining and repairing a wide range of mining mobile equipment. This role requires strong diagnostic skills, mechanical expertise, and the ability to work in a fast-paced, safety-focused environment. Candidates must be comfortable working extended 12-hour shifts and rotating between day and night schedules if needed.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nPerform routine maintenance, diagnostics, and repairs on heavy mining equipment including:\n<ul>\n<li>\nExcavators\n<\/li>\n<li>\nDozers\n<\/li>\n<li>\nHaul trucks (40-ton to 100-ton)\n<\/li>\n<li>\nWater trucks\n<\/li>\n<li>\nMotor graders\n<\/li>\n<\/ul>\n<\/li>\n<li>\nTroubleshoot mechanical, hydraulic, and electrical issues efficiently\n<\/li>\n<li>\nConduct preventative maintenance inspections and servicing\n<\/li>\n<li>\nRead and interpret technical manuals, schematics, and diagnostic codes\n<\/li>\n<li>\nEnsure all repairs meet safety and operational standards\n<\/li>\n<li>\nMaintain accurate service records and documentation\n<\/li>\n<li>\nWork collaboratively with operators and other maintenance personnel\n<\/li>\n<li>\nAdhere to all company safety policies and MSHA regulations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n3+ years of experience as a heavy equipment mechanic (mining or construction)\n<\/li>\n<li>\nStrong knowledge of diesel engines, hydraulics, and electrical systems\n<\/li>\n<li>\nExperience working on large haul trucks and earthmoving equipment preferred\n<\/li>\n<li>\nAbility to diagnose and repair equipment with minimal supervision\n<\/li>\n<li>\nMust be willing to work 12-hour shifts, including nights, weekends, and overtime as needed\n<\/li>\n<li>\nValid driver\u2019s license required&nbsp;<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\nStrong troubleshooting and problem-solving skills\n<\/li>\n<li>\nMechanical aptitude and attention to detail\n<\/li>\n<li>\nAbility to work independently and as part of a team\n<\/li>\n<li>\nStrong commitment to safety and compliance\n<\/li>\n<li>\nEffective communication skills\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to varying weather conditions\n<\/li>\n<li>\nPhysically demanding role requiring lifting, climbing, and extended periods of standing\n<\/li>\n<li>\nMust be comfortable working around heavy machinery and in high-noise environments<\/li><\/ul>","post_title":"Heavy Equipment Mechanic &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-traveling-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Winnemucca, NV","%education%":"","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong> Heavy Equipment Mechanic (Mining Equipment)<br>\n<strong>Schedule:<\/strong> 12-hour shifts&nbsp;<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking an experienced <strong>Heavy Equipment Mechanic<\/strong> to join our team, responsible for maintaining and repairing a wide range of mining mobile equipment. This role requires strong diagnostic skills, mechanical expertise, and the ability to work in a fast-paced, safety-focused environment. Candidates must be comfortable working extended 12-hour shifts and rotating between day and night schedules if needed.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nPerform routine maintenance, diagnostics, and repairs on heavy mining equipment including:\n<ul>\n<li>\nExcavators\n<\/li>\n<li>\nDozers\n<\/li>\n<li>\nHaul trucks (40-ton to 100-ton)\n<\/li>\n<li>\nWater trucks\n<\/li>\n<li>\nMotor graders\n<\/li>\n<\/ul>\n<\/li>\n<li>\nTroubleshoot mechanical, hydraulic, and electrical issues efficiently\n<\/li>\n<li>\nConduct preventative maintenance inspections and servicing\n<\/li>\n<li>\nRead and interpret technical manuals, schematics, and diagnostic codes\n<\/li>\n<li>\nEnsure all repairs meet safety and operational standards\n<\/li>\n<li>\nMaintain accurate service records and documentation\n<\/li>\n<li>\nWork collaboratively with operators and other maintenance personnel\n<\/li>\n<li>\nAdhere to all company safety policies and MSHA regulations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n3+ years of experience as a heavy equipment mechanic (mining or construction)\n<\/li>\n<li>\nStrong knowledge of diesel engines, hydraulics, and electrical systems\n<\/li>\n<li>\nExperience working on large haul trucks and earthmoving equipment preferred\n<\/li>\n<li>\nAbility to diagnose and repair equipment with minimal supervision\n<\/li>\n<li>\nMust be willing to work 12-hour shifts, including nights, weekends, and overtime as needed\n<\/li>\n<li>\nValid driver\u2019s license required&nbsp;<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\nStrong troubleshooting and problem-solving skills\n<\/li>\n<li>\nMechanical aptitude and attention to detail\n<\/li>\n<li>\nAbility to work independently and as part of a team\n<\/li>\n<li>\nStrong commitment to safety and compliance\n<\/li>\n<li>\nEffective communication skills\n<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to varying weather conditions\n<\/li>\n<li>\nPhysically demanding role requiring lifting, climbing, and extended periods of standing\n<\/li>\n<li>\nMust be comfortable working around heavy machinery and in high-noise environments<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/c474e5800adf-heavy-equipment-mechanic-traveling","%breezy_id%":"c474e5800adf","%breezy_friendly_id%":"c474e5800adf-heavy-equipment-mechanic-traveling","%breezy_created_date%":"2026-04-20T19:47:10.529Z","%breezy_updated_date%":"2026-05-18T20:50:52.389Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"253"}},"id":3520,"infowindow_disable":false},{"source":"post","title":"Surveyor -Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Surveyor -Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Mine Surveyor Position Overview We are seeking a skilled Mine Surveyor to support daily mining operations through accurate&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/surveyor-traveling-3\/\" name=\"Surveyor -Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Mine Surveyor Position Overview We are seeking a skilled Mine Surveyor to support daily mining operations through accurate&hellip;","address":"Winnemucca, NV, USA","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/surveyor-traveling-3\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Mine Surveyor Position Overview We are seeking a skilled Mine Surveyor to support daily mining operations through accurate&hellip;","post_content":"<p><strong>Job Title:<\/strong> Mine Surveyor<br><\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a skilled <strong>Mine Surveyor<\/strong> to support daily mining operations through accurate layout, data management, and field surveying. This role is critical to ensuring safe and efficient production by providing precise survey control, maintaining equipment, and coordinating with engineering and operations teams. Candidates with mining or heavy civil construction surveying experience are encouraged to apply.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nPerform survey functions in support of mine operations and project scope\n<\/li>\n<li>\nConduct daily field staking and layout in accordance with mine plans and designs\n<\/li>\n<li>\nComplete quantity takeoffs, volume calculations, and material tracking\n<\/li>\n<li>\nCommunicate layout and survey data clearly to operators, supervisors, and site personnel\n<\/li>\n<li>\nTroubleshoot survey layouts and machine control data to ensure accuracy and consistency\n<\/li>\n<li>\nMaintain, calibrate, troubleshoot, and repair survey equipment\n<\/li>\n<li>\nCoordinate with mine engineers and design teams regarding plans, updates, and changes\n<\/li>\n<li>\nEnsure all survey work meets project specifications and quality standards\n<\/li>\n<li>\nOperate and communicate via 2-way radio\n<\/li>\n<li>\nMaintain accurate survey records and documentation\n<\/li>\n<\/ul>\n<h3><strong>Safety &amp; Compliance<\/strong><\/h3>\n<ul>\n<li>\nAdhere to all company safety policies, procedures, and PPE requirements\n<\/li>\n<li>\nConduct Job Safety Analyses (JSA) and Field Level Hazard Assessments (FLHA) as required\n<\/li>\n<li>\nMaintain strong situational awareness of heavy equipment, personnel, and site hazards\n<\/li>\n<li>\nSupport and promote a strong safety culture on site\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of 2+ years of surveying experience (mining or construction)\n<\/li>\n<li>\nExtensive GPS construction layout experience using Trimble or Topcon equipment\n<\/li>\n<li>\nExperience with machine control systems preferred\n<\/li>\n<li>\nHigh School Diploma required\n<\/li>\n<li>\nPost-secondary education in surveying or related field (technical school preferred)\n<\/li>\n<li>\nAbility to read and interpret mine plans, engineering drawings, and specifications\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\nStrong problem-solving and troubleshooting skills\n<\/li>\n<li>\nHigh level of accuracy and attention to detail\n<\/li>\n<li>\nAbility to work independently and within a team environment\n<\/li>\n<li>\nEffective communication across multiple departments\n<\/li>\n<li>\nAdaptability in a fast-paced, production-driven environment\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibrations, and varying weather conditions\n<\/li>\n<li>\nAbility to safely and repetitively lift up to 50 lbs\n<\/li>\n<li>\nPhysically demanding role requiring standing, walking, and climbing<\/li>\n<li>\nFlexibility to assist with general labor duties as needed<\/li><\/ul>","post_title":"Surveyor -Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/surveyor-traveling-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Winnemucca, NV","%education%":"","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong> Mine Surveyor<br><\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a skilled <strong>Mine Surveyor<\/strong> to support daily mining operations through accurate layout, data management, and field surveying. This role is critical to ensuring safe and efficient production by providing precise survey control, maintaining equipment, and coordinating with engineering and operations teams. Candidates with mining or heavy civil construction surveying experience are encouraged to apply.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nPerform survey functions in support of mine operations and project scope\n<\/li>\n<li>\nConduct daily field staking and layout in accordance with mine plans and designs\n<\/li>\n<li>\nComplete quantity takeoffs, volume calculations, and material tracking\n<\/li>\n<li>\nCommunicate layout and survey data clearly to operators, supervisors, and site personnel\n<\/li>\n<li>\nTroubleshoot survey layouts and machine control data to ensure accuracy and consistency\n<\/li>\n<li>\nMaintain, calibrate, troubleshoot, and repair survey equipment\n<\/li>\n<li>\nCoordinate with mine engineers and design teams regarding plans, updates, and changes\n<\/li>\n<li>\nEnsure all survey work meets project specifications and quality standards\n<\/li>\n<li>\nOperate and communicate via 2-way radio\n<\/li>\n<li>\nMaintain accurate survey records and documentation\n<\/li>\n<\/ul>\n<h3><strong>Safety &amp; Compliance<\/strong><\/h3>\n<ul>\n<li>\nAdhere to all company safety policies, procedures, and PPE requirements\n<\/li>\n<li>\nConduct Job Safety Analyses (JSA) and Field Level Hazard Assessments (FLHA) as required\n<\/li>\n<li>\nMaintain strong situational awareness of heavy equipment, personnel, and site hazards\n<\/li>\n<li>\nSupport and promote a strong safety culture on site\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of 2+ years of surveying experience (mining or construction)\n<\/li>\n<li>\nExtensive GPS construction layout experience using Trimble or Topcon equipment\n<\/li>\n<li>\nExperience with machine control systems preferred\n<\/li>\n<li>\nHigh School Diploma required\n<\/li>\n<li>\nPost-secondary education in surveying or related field (technical school preferred)\n<\/li>\n<li>\nAbility to read and interpret mine plans, engineering drawings, and specifications\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\nStrong problem-solving and troubleshooting skills\n<\/li>\n<li>\nHigh level of accuracy and attention to detail\n<\/li>\n<li>\nAbility to work independently and within a team environment\n<\/li>\n<li>\nEffective communication across multiple departments\n<\/li>\n<li>\nAdaptability in a fast-paced, production-driven environment\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibrations, and varying weather conditions\n<\/li>\n<li>\nAbility to safely and repetitively lift up to 50 lbs\n<\/li>\n<li>\nPhysically demanding role requiring standing, walking, and climbing<\/li>\n<li>\nFlexibility to assist with general labor duties as needed<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/2b9e8af96442-surveyor-traveling","%breezy_id%":"2b9e8af96442","%breezy_friendly_id%":"2b9e8af96442-surveyor-traveling","%breezy_created_date%":"2026-04-20T17:07:32.903Z","%breezy_updated_date%":"2026-05-18T20:52:49.270Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"252"}},"id":3516,"infowindow_disable":false},{"source":"post","title":"Surveyor -Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Surveyor -Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Mine Surveyor Position Overview We are seeking a skilled Mine Surveyor to support daily mining operations through accurate&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/surveyor-traveling\/\" name=\"Surveyor -Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Mine Surveyor Position Overview We are seeking a skilled Mine Surveyor to support daily mining operations through accurate&hellip;","address":"Las Vegas, NV, USA","location":{"lat":"36.171563","city":"Las Vegas","state":"NV","country":"United States","lng":"-115.1391009","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/surveyor-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Mine Surveyor Position Overview We are seeking a skilled Mine Surveyor to support daily mining operations through accurate&hellip;","post_content":"<p><strong>Job Title:<\/strong> Mine Surveyor<br><\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a skilled <strong>Mine Surveyor<\/strong> to support daily mining operations through accurate layout, data management, and field surveying. This role is critical to ensuring safe and efficient production by providing precise survey control, maintaining equipment, and coordinating with engineering and operations teams. Candidates with mining or heavy civil construction surveying experience are encouraged to apply.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nPerform survey functions in support of mine operations and project scope\n<\/li>\n<li>\nConduct daily field staking and layout in accordance with mine plans and designs\n<\/li>\n<li>\nComplete quantity takeoffs, volume calculations, and material tracking\n<\/li>\n<li>\nCommunicate layout and survey data clearly to operators, supervisors, and site personnel\n<\/li>\n<li>\nTroubleshoot survey layouts and machine control data to ensure accuracy and consistency\n<\/li>\n<li>\nMaintain, calibrate, troubleshoot, and repair survey equipment\n<\/li>\n<li>\nCoordinate with mine engineers and design teams regarding plans, updates, and changes\n<\/li>\n<li>\nEnsure all survey work meets project specifications and quality standards\n<\/li>\n<li>\nOperate and communicate via 2-way radio\n<\/li>\n<li>\nMaintain accurate survey records and documentation\n<\/li>\n<\/ul>\n<h3><strong>Safety &amp; Compliance<\/strong><\/h3>\n<ul>\n<li>\nAdhere to all company safety policies, procedures, and PPE requirements\n<\/li>\n<li>\nConduct Job Safety Analyses (JSA) and Field Level Hazard Assessments (FLHA) as required\n<\/li>\n<li>\nMaintain strong situational awareness of heavy equipment, personnel, and site hazards\n<\/li>\n<li>\nSupport and promote a strong safety culture on site\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of 2+ years of surveying experience (mining or construction)\n<\/li>\n<li>\nExtensive GPS construction layout experience using Trimble or Topcon equipment\n<\/li>\n<li>\nExperience with machine control systems preferred\n<\/li>\n<li>\nHigh School Diploma required\n<\/li>\n<li>\nPost-secondary education in surveying or related field (technical school preferred)\n<\/li>\n<li>\nAbility to read and interpret mine plans, engineering drawings, and specifications\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\nStrong problem-solving and troubleshooting skills\n<\/li>\n<li>\nHigh level of accuracy and attention to detail\n<\/li>\n<li>\nAbility to work independently and within a team environment\n<\/li>\n<li>\nEffective communication across multiple departments\n<\/li>\n<li>\nAdaptability in a fast-paced, production-driven environment\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibrations, and varying weather conditions\n<\/li>\n<li>\nAbility to safely and repetitively lift up to 50 lbs\n<\/li>\n<li>\nPhysically demanding role requiring standing, walking, and climbing<\/li>\n<li>\nFlexibility to assist with general labor duties as needed<\/li><\/ul>","post_title":"Surveyor -Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/surveyor-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Las Vegas","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Las Vegas, NV","%education%":"","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong> Mine Surveyor<br><\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a skilled <strong>Mine Surveyor<\/strong> to support daily mining operations through accurate layout, data management, and field surveying. This role is critical to ensuring safe and efficient production by providing precise survey control, maintaining equipment, and coordinating with engineering and operations teams. Candidates with mining or heavy civil construction surveying experience are encouraged to apply.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nPerform survey functions in support of mine operations and project scope\n<\/li>\n<li>\nConduct daily field staking and layout in accordance with mine plans and designs\n<\/li>\n<li>\nComplete quantity takeoffs, volume calculations, and material tracking\n<\/li>\n<li>\nCommunicate layout and survey data clearly to operators, supervisors, and site personnel\n<\/li>\n<li>\nTroubleshoot survey layouts and machine control data to ensure accuracy and consistency\n<\/li>\n<li>\nMaintain, calibrate, troubleshoot, and repair survey equipment\n<\/li>\n<li>\nCoordinate with mine engineers and design teams regarding plans, updates, and changes\n<\/li>\n<li>\nEnsure all survey work meets project specifications and quality standards\n<\/li>\n<li>\nOperate and communicate via 2-way radio\n<\/li>\n<li>\nMaintain accurate survey records and documentation\n<\/li>\n<\/ul>\n<h3><strong>Safety &amp; Compliance<\/strong><\/h3>\n<ul>\n<li>\nAdhere to all company safety policies, procedures, and PPE requirements\n<\/li>\n<li>\nConduct Job Safety Analyses (JSA) and Field Level Hazard Assessments (FLHA) as required\n<\/li>\n<li>\nMaintain strong situational awareness of heavy equipment, personnel, and site hazards\n<\/li>\n<li>\nSupport and promote a strong safety culture on site\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of 2+ years of surveying experience (mining or construction)\n<\/li>\n<li>\nExtensive GPS construction layout experience using Trimble or Topcon equipment\n<\/li>\n<li>\nExperience with machine control systems preferred\n<\/li>\n<li>\nHigh School Diploma required\n<\/li>\n<li>\nPost-secondary education in surveying or related field (technical school preferred)\n<\/li>\n<li>\nAbility to read and interpret mine plans, engineering drawings, and specifications\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Competencies<\/strong><\/h3>\n<ul>\n<li>\nStrong problem-solving and troubleshooting skills\n<\/li>\n<li>\nHigh level of accuracy and attention to detail\n<\/li>\n<li>\nAbility to work independently and within a team environment\n<\/li>\n<li>\nEffective communication across multiple departments\n<\/li>\n<li>\nAdaptability in a fast-paced, production-driven environment\n<\/li>\n<\/ul>\n<h3><strong>Work Environment &amp; Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibrations, and varying weather conditions\n<\/li>\n<li>\nAbility to safely and repetitively lift up to 50 lbs\n<\/li>\n<li>\nPhysically demanding role requiring standing, walking, and climbing<\/li>\n<li>\nFlexibility to assist with general labor duties as needed<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/806a109700a5-surveyor-traveling","%breezy_id%":"806a109700a5","%breezy_friendly_id%":"806a109700a5-surveyor-traveling","%breezy_created_date%":"2026-04-20T15:29:25.215Z","%breezy_updated_date%":"2026-05-18T20:47:26.812Z","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Las Vegas, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.171563","%_wpgmp_metabox_longitude%":"-115.1391009","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"250"}},"id":3513,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling\/\" name=\"Haul Truck Operator &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;","address":"Las Vegas, NV, USA","location":{"lat":"36.171563","city":"Las Vegas","state":"NV","country":"United States","lng":"-115.1391009","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title:&nbsp;Haul Truck Operator Schedule: 12-hour shifts Position Overview We are seeking a dependable and safety-focused Haul Truck Operator to&hellip;","post_content":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Operator<br>\n<strong>Schedule:<\/strong> 12-hour shifts<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and safety-focused <strong>Haul Truck Operator<\/strong> to join our mining operations team. This role is responsible for safely operating heavy haul trucks in an active mine environment to transport material efficiently and in accordance with site safety standards. The ideal candidate will have a minimum of 2 years of experience operating <strong>40-ton to 100-ton haul trucks<\/strong> and must be willing to work 12-hour shifts, and be open to&nbsp;day and night schedules.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSafely operate mine haul trucks in an active mining environment\n<\/li>\n<li>\nTransport materials efficiently to designated locations\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nReport mechanical issues, safety concerns, or unsafe conditions immediately\n<\/li>\n<li>\nFollow all site safety procedures, traffic patterns, and operational rules\n<\/li>\n<li>\nCommunicate effectively with supervisors, dispatch, and other equipment operators\n<\/li>\n<li>\nMaintain productivity while operating equipment safely and responsibly\n<\/li>\n<li>\nAssist with other duties as needed to support site operations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of <strong>2 years of experience<\/strong> operating <strong>40-ton to 100-ton haul trucks<\/strong>\n<\/li>\n<li>\nPrevious mining or heavy civil experience preferred\n<\/li>\n<li>\nMust be able to work <strong>12-hour shifts<\/strong>\n<\/li>\n<li>\nMust be open to <strong>day and night shift schedules<\/strong>\n<\/li>\n<li>\nStrong understanding of safe equipment operation and site awareness\n<\/li>\n<li>\n<strong>MSHA certification preferred<\/strong>\n<\/li>\n<li>\nValid driver\u2019s license&nbsp;<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibration, and varying weather conditions\n<\/li>\n<li>\nWork around heavy equipment, trucks, and active site traffic\n<\/li>\n<li>\nPhysically demanding role requiring attention to detail and strong safety awareness<\/li><\/ul>","post_title":"Haul Truck Operator &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Las Vegas","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Las Vegas, NV","%education%":"","%department%":"TSG","%description%":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Operator<br>\n<strong>Schedule:<\/strong> 12-hour shifts<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and safety-focused <strong>Haul Truck Operator<\/strong> to join our mining operations team. This role is responsible for safely operating heavy haul trucks in an active mine environment to transport material efficiently and in accordance with site safety standards. The ideal candidate will have a minimum of 2 years of experience operating <strong>40-ton to 100-ton haul trucks<\/strong> and must be willing to work 12-hour shifts, and be open to&nbsp;day and night schedules.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nSafely operate mine haul trucks in an active mining environment\n<\/li>\n<li>\nTransport materials efficiently to designated locations\n<\/li>\n<li>\nPerform pre-shift and post-shift inspections of equipment\n<\/li>\n<li>\nReport mechanical issues, safety concerns, or unsafe conditions immediately\n<\/li>\n<li>\nFollow all site safety procedures, traffic patterns, and operational rules\n<\/li>\n<li>\nCommunicate effectively with supervisors, dispatch, and other equipment operators\n<\/li>\n<li>\nMaintain productivity while operating equipment safely and responsibly\n<\/li>\n<li>\nAssist with other duties as needed to support site operations\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMinimum of <strong>2 years of experience<\/strong> operating <strong>40-ton to 100-ton haul trucks<\/strong>\n<\/li>\n<li>\nPrevious mining or heavy civil experience preferred\n<\/li>\n<li>\nMust be able to work <strong>12-hour shifts<\/strong>\n<\/li>\n<li>\nMust be open to <strong>day and night shift schedules<\/strong>\n<\/li>\n<li>\nStrong understanding of safe equipment operation and site awareness\n<\/li>\n<li>\n<strong>MSHA certification preferred<\/strong>\n<\/li>\n<li>\nValid driver\u2019s license&nbsp;<\/li>\n<\/ul>\n<h3><strong>Work Environment<\/strong><\/h3>\n<ul>\n<li>\nOutdoor mining environment with exposure to dust, noise, vibration, and varying weather conditions\n<\/li>\n<li>\nWork around heavy equipment, trucks, and active site traffic\n<\/li>\n<li>\nPhysically demanding role requiring attention to detail and strong safety awareness<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/632d38ec1d4a-haul-truck-operator-traveling","%breezy_id%":"632d38ec1d4a","%breezy_friendly_id%":"632d38ec1d4a-haul-truck-operator-traveling","%breezy_created_date%":"2026-04-20T15:39:45.671Z","%breezy_updated_date%":"2026-05-18T20:48:50.896Z","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Las Vegas, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.171563","%_wpgmp_metabox_longitude%":"-115.1391009","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"251"}},"id":3514,"infowindow_disable":false},{"source":"post","title":"Safety Advisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Safety Advisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Summary Turner Staffing Group is seeking an experienced Health &amp; Safety Advisor to support heavy civil, construction, road building,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/safety-advisor\/\" name=\"Safety Advisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Summary Turner Staffing Group is seeking an experienced Health &amp; Safety Advisor to support heavy civil, construction, road building,&hellip;","address":"Winnemucca, NV, USA","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/safety-advisor\/","zoom":19,"extra_fields":{"post_excerpt":"Position Summary Turner Staffing Group is seeking an experienced Health &amp; Safety Advisor to support heavy civil, construction, road building,&hellip;","post_content":"<h3>Position Summary<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Health &amp; Safety Advisor<\/strong> to support heavy civil, construction, road building, and mining project sites. This field\u2011based role focuses on promoting a strong safety culture, ensuring regulatory compliance, and providing hands\u2011on safety leadership across multiple project locations.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>Deliver field\u2011level safety orientations and lead safety meetings<\/li>\n<li>Promote and model safe work behaviors and best practices<\/li>\n<li>Conduct site inspections, audits, and hazard assessments<\/li>\n<li>Support incident and near\u2011miss investigations<\/li>\n<li>Monitor compliance with Turner Staffing Group\u2019s Safe Work Practices and PPE policies<\/li>\n<li>Collaborate with workers, supervisors, and management to identify and mitigate hazards<\/li>\n<li>Track safety trends and recommend continuous improvements<\/li>\n<li>Travel to multiple project sites as required<\/li>\n<\/ul>\n<h3>Requirements<\/h3>\n<ul>\n<li>Minimum <strong>5 years\u2019 experience<\/strong> as a Health &amp; Safety Advisor in heavy civil, construction, or mining environments<\/li>\n<li>Strong knowledge of <strong>provincial OH&amp;S regulations<\/strong><\/li>\n<li>MSHA Part 48 certification or ability to obtain<\/li>\n<li>Alcohol and Drug Screening (pre\u2011employment)<\/li>\n<li>Ability to lift up to <strong>50 lbs<\/strong> and work <strong>12\u2011hour rotational day\/night shifts<\/strong><\/li>\n<li>Comfortable working outdoors in all weather conditions<\/li>\n<li>Strong communication, organization, and problem\u2011solving skills<\/li>\n<li>High school diploma required; post\u2011secondary education an asset<\/li><\/ul>\n<p><\/p>","post_title":"Safety Advisor","post_link":"https:\/\/turnerstaffing.com\/position\/safety-advisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Winnemucca, NV","%education%":"Unspecified","%description%":"<h3>Position Summary<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Health &amp; Safety Advisor<\/strong> to support heavy civil, construction, road building, and mining project sites. This field\u2011based role focuses on promoting a strong safety culture, ensuring regulatory compliance, and providing hands\u2011on safety leadership across multiple project locations.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>Deliver field\u2011level safety orientations and lead safety meetings<\/li>\n<li>Promote and model safe work behaviors and best practices<\/li>\n<li>Conduct site inspections, audits, and hazard assessments<\/li>\n<li>Support incident and near\u2011miss investigations<\/li>\n<li>Monitor compliance with Turner Staffing Group\u2019s Safe Work Practices and PPE policies<\/li>\n<li>Collaborate with workers, supervisors, and management to identify and mitigate hazards<\/li>\n<li>Track safety trends and recommend continuous improvements<\/li>\n<li>Travel to multiple project sites as required<\/li>\n<\/ul>\n<h3>Requirements<\/h3>\n<ul>\n<li>Minimum <strong>5 years\u2019 experience<\/strong> as a Health &amp; Safety Advisor in heavy civil, construction, or mining environments<\/li>\n<li>Strong knowledge of <strong>provincial OH&amp;S regulations<\/strong><\/li>\n<li>MSHA Part 48 certification or ability to obtain<\/li>\n<li>Alcohol and Drug Screening (pre\u2011employment)<\/li>\n<li>Ability to lift up to <strong>50 lbs<\/strong> and work <strong>12\u2011hour rotational day\/night shifts<\/strong><\/li>\n<li>Comfortable working outdoors in all weather conditions<\/li>\n<li>Strong communication, organization, and problem\u2011solving skills<\/li>\n<li>High school diploma required; post\u2011secondary education an asset<\/li><\/ul>\n<p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/7b0f3541e583-safety-advisor","%breezy_id%":"7b0f3541e583","%breezy_friendly_id%":"7b0f3541e583-safety-advisor","%breezy_created_date%":"2026-04-17T23:45:19.720Z","%breezy_updated_date%":"2026-05-18T20:51:40.677Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1","%_edit_lock%":"1777583840:4","%rank_math_seo_score%":"10","%_edit_last%":"4","%_wpgmp_metabox_custom_link%":"","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_ame_cpe_post_policy%":"{\"accessProtection\":{\"active\":\"replace\"}}","%rank_math_analytic_object_id%":"239","%department%":"TSG"}},"id":3505,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator- Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator- Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling\/\" name=\"Heavy Equipment Operator- Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction,&hellip;","address":"Las Vegas, NV, USA","location":{"lat":"36.171563","city":"Las Vegas","state":"NV","country":"United States","lng":"-115.1391009","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction,&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction, and industrial sectors. We are currently seeking experienced Heavy Equipment Operators to support a mining client in a fast-paced production environment. This is an excellent opportunity for safety-focused individuals with mobile equipment experience who are looking to grow their careers in mining operations.<\/p>\n<h3>Position Summary<\/h3>\n<p>The traveling&nbsp;Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining operations. Equipment may include haul trucks, loaders, excavators, water trucks, dozers, graders, and other production support machinery. Operators play a critical role in maintaining production goals while adhering to strict safety and operational standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nOperate heavy mobile equipment in a safe, efficient, and productive manner\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections and complete required documentation\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions promptly\n<\/li>\n<li>\nFollow mine site safety procedures, policies, and MSHA regulations at all times\n<\/li>\n<li>\nWork closely with supervisors, dispatch, and other team members to meet daily production targets\n<\/li>\n<li>\nMaintain clean and orderly equipment cabs and work areas\n<\/li>\n<li>\nAssist with general mine site tasks as needed to support operations\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating heavy equipment in mining, quarry, construction, or similar industrial environments preferred\n<\/li>\n<li>\nAbility to safely operate one or more types of mobile equipment such as haul trucks, loaders, excavators, or dozers\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong understanding of equipment safety protocols and hazard awareness\n<\/li>\n<li>\nAbility to work in varying weather and site conditions\n<\/li>\n<li>\nReliable transportation and strong attendance record\n<\/li>\n<li>\nAbility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to sit, stand, climb, bend, and walk for extended periods\n<\/li>\n<li>\nAbility to climb in and out of heavy equipment multiple times per shift\n<\/li>\n<li>\nMust be able to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to work in dusty, rugged outdoor environments<\/li><\/ul>","post_title":"Heavy Equipment Operator- Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Las Vegas","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Las Vegas, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction, and industrial sectors. We are currently seeking experienced Heavy Equipment Operators to support a mining client in a fast-paced production environment. This is an excellent opportunity for safety-focused individuals with mobile equipment experience who are looking to grow their careers in mining operations.<\/p>\n<h3>Position Summary<\/h3>\n<p>The traveling&nbsp;Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining operations. Equipment may include haul trucks, loaders, excavators, water trucks, dozers, graders, and other production support machinery. Operators play a critical role in maintaining production goals while adhering to strict safety and operational standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nOperate heavy mobile equipment in a safe, efficient, and productive manner\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections and complete required documentation\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions promptly\n<\/li>\n<li>\nFollow mine site safety procedures, policies, and MSHA regulations at all times\n<\/li>\n<li>\nWork closely with supervisors, dispatch, and other team members to meet daily production targets\n<\/li>\n<li>\nMaintain clean and orderly equipment cabs and work areas\n<\/li>\n<li>\nAssist with general mine site tasks as needed to support operations\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating heavy equipment in mining, quarry, construction, or similar industrial environments preferred\n<\/li>\n<li>\nAbility to safely operate one or more types of mobile equipment such as haul trucks, loaders, excavators, or dozers\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong understanding of equipment safety protocols and hazard awareness\n<\/li>\n<li>\nAbility to work in varying weather and site conditions\n<\/li>\n<li>\nReliable transportation and strong attendance record\n<\/li>\n<li>\nAbility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to sit, stand, climb, bend, and walk for extended periods\n<\/li>\n<li>\nAbility to climb in and out of heavy equipment multiple times per shift\n<\/li>\n<li>\nMust be able to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to work in dusty, rugged outdoor environments<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/bc9c0e20b927-heavy-equipment-operator-traveling","%breezy_id%":"bc9c0e20b927","%breezy_friendly_id%":"bc9c0e20b927-heavy-equipment-operator-traveling","%breezy_created_date%":"2026-04-15T12:42:43.466Z","%breezy_updated_date%":"2026-05-18T20:46:28.071Z","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Las Vegas, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.171563","%_wpgmp_metabox_longitude%":"-115.1391009","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"249"}},"id":3456,"infowindow_disable":false},{"source":"post","title":"General Laborer- Mining- Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Laborer- Mining- Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-traveling\/\" name=\"General Laborer- Mining- Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations.&hellip;","address":"Las Vegas, NV, USA","location":{"lat":"36.171563","city":"Las Vegas","state":"NV","country":"United States","lng":"-115.1391009","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations.&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations. We are currently seeking motivated General Laborers to support a mining client in a dynamic production environment. This role is ideal for individuals who are safety-conscious, reliable, and eager to work in a hands-on mining setting.<\/p>\n<h3>Position Summary<\/h3>\n<p>The traveling General Laborer is responsible for performing a variety of physical tasks that support daily mining site operations. This role assists equipment operators, maintenance personnel, and site supervisors with general site cleanup, material handling, equipment support, and other labor-intensive duties necessary to keep operations running safely and efficiently.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nPerform general physical labor duties in support of mining operations\n<\/li>\n<li>\nAssist with site cleanup, shoveling, sweeping, and debris removal around work areas\n<\/li>\n<li>\nSupport equipment operators and maintenance crews as needed\n<\/li>\n<li>\nLoad and unload materials, tools, and supplies\n<\/li>\n<li>\nMaintain safe, clean, and organized work areas\n<\/li>\n<li>\nFollow all mine site safety rules, procedures, and MSHA regulations\n<\/li>\n<li>\nIdentify and report unsafe conditions or equipment issues promptly\n<\/li>\n<li>\nUse hand tools and basic equipment safely and effectively\n<\/li>\n<li>\nComplete additional tasks assigned by supervisors to support production needs\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious labor experience in mining, construction, industrial, or outdoor environments preferred\n<\/li>\n<li>\nAbility to perform physically demanding work in rugged outdoor conditions\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong work ethic and willingness to learn\n<\/li>\n<li>\nAbility to follow instructions and work effectively as part of a team\n<\/li>\n<li>\nReliable transportation and dependable attendance required\n<\/li>\n<li>\nFlexibility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to lift, carry, push, and pull up to 50 pounds regularly\n<\/li>\n<li>\nAbility to stand, walk, bend, kneel, stoop, and climb for extended periods\n<\/li>\n<li>\nAbility to work outdoors in varying weather, dust, noise, and uneven terrain\n<\/li>\n<li>\nMust be able to wear required PPE at all times on site<\/li><\/ul>","post_title":"General Laborer- Mining- Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Las Vegas","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Las Vegas, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations. We are currently seeking motivated General Laborers to support a mining client in a dynamic production environment. This role is ideal for individuals who are safety-conscious, reliable, and eager to work in a hands-on mining setting.<\/p>\n<h3>Position Summary<\/h3>\n<p>The traveling General Laborer is responsible for performing a variety of physical tasks that support daily mining site operations. This role assists equipment operators, maintenance personnel, and site supervisors with general site cleanup, material handling, equipment support, and other labor-intensive duties necessary to keep operations running safely and efficiently.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nPerform general physical labor duties in support of mining operations\n<\/li>\n<li>\nAssist with site cleanup, shoveling, sweeping, and debris removal around work areas\n<\/li>\n<li>\nSupport equipment operators and maintenance crews as needed\n<\/li>\n<li>\nLoad and unload materials, tools, and supplies\n<\/li>\n<li>\nMaintain safe, clean, and organized work areas\n<\/li>\n<li>\nFollow all mine site safety rules, procedures, and MSHA regulations\n<\/li>\n<li>\nIdentify and report unsafe conditions or equipment issues promptly\n<\/li>\n<li>\nUse hand tools and basic equipment safely and effectively\n<\/li>\n<li>\nComplete additional tasks assigned by supervisors to support production needs\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious labor experience in mining, construction, industrial, or outdoor environments preferred\n<\/li>\n<li>\nAbility to perform physically demanding work in rugged outdoor conditions\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong work ethic and willingness to learn\n<\/li>\n<li>\nAbility to follow instructions and work effectively as part of a team\n<\/li>\n<li>\nReliable transportation and dependable attendance required\n<\/li>\n<li>\nFlexibility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to lift, carry, push, and pull up to 50 pounds regularly\n<\/li>\n<li>\nAbility to stand, walk, bend, kneel, stoop, and climb for extended periods\n<\/li>\n<li>\nAbility to work outdoors in varying weather, dust, noise, and uneven terrain\n<\/li>\n<li>\nMust be able to wear required PPE at all times on site<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/8b28f14a9c89-general-laborer-mining--traveling","%breezy_id%":"8b28f14a9c89","%breezy_friendly_id%":"8b28f14a9c89-general-laborer-mining--traveling","%breezy_created_date%":"2026-04-15T12:41:21.775Z","%breezy_updated_date%":"2026-05-18T13:02:21.083Z","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Las Vegas, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.171563","%_wpgmp_metabox_longitude%":"-115.1391009","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"248"}},"id":3455,"infowindow_disable":false},{"source":"post","title":"Mining Foreman- Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Foreman- Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-foreman-traveling\/\" name=\"Mining Foreman- Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;","address":"Las Vegas, NV, USA","location":{"lat":"36.171563","city":"Las Vegas","state":"NV","country":"United States","lng":"-115.1391009","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-foreman-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety, and operational excellence. We are currently seeking an experienced traveling Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nSupervise and direct daily activities of mining crews, equipment operators, and labor personnel\n<\/li>\n<li>\nCoordinate production schedules to meet daily and weekly output targets\n<\/li>\n<li>\nMonitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures\n<\/li>\n<li>\nEnforce mine safety standards, company policies, and MSHA regulations at all times\n<\/li>\n<li>\nConduct pre-shift meetings, safety briefings, and crew assignments\n<\/li>\n<li>\nInspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies\n<\/li>\n<li>\nCommunicate with management regarding production progress, staffing needs, and operational concerns\n<\/li>\n<li>\nEnsure equipment is being operated properly and maintenance issues are reported promptly\n<\/li>\n<li>\nTrain and mentor crew members on safe work practices and operational procedures\n<\/li>\n<li>\nMaintain accurate shift reports, production logs, and incident documentation\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious supervisory experience in mining operations required\n<\/li>\n<li>\nStrong knowledge of surface or underground mining processes (depending on site application)\n<\/li>\n<li>\nExperience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers\n<\/li>\n<li>\nMSHA certification required or ability to obtain\/maintain certification as required by site\n<\/li>\n<li>\nProven leadership, communication, and decision-making skills\n<\/li>\n<li>\nAbility to prioritize tasks and manage multiple crews in a fast-paced environment\n<\/li>\n<li>\nStrong understanding of workplace safety and hazard recognition practices\n<\/li>\n<li>\nProficient in basic reporting, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to work in active mining environments, including exposure to dust, noise, and varying weather conditions\n<\/li>\n<li>\nAbility to walk uneven terrain, climb equipment\/access points, and remain active throughout shift\n<\/li>\n<li>\nAbility to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to wear all required PPE on site<\/li><\/ul>","post_title":"Mining Foreman- Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/mining-foreman-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Las Vegas","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Las Vegas, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety, and operational excellence. We are currently seeking an experienced traveling Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nSupervise and direct daily activities of mining crews, equipment operators, and labor personnel\n<\/li>\n<li>\nCoordinate production schedules to meet daily and weekly output targets\n<\/li>\n<li>\nMonitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures\n<\/li>\n<li>\nEnforce mine safety standards, company policies, and MSHA regulations at all times\n<\/li>\n<li>\nConduct pre-shift meetings, safety briefings, and crew assignments\n<\/li>\n<li>\nInspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies\n<\/li>\n<li>\nCommunicate with management regarding production progress, staffing needs, and operational concerns\n<\/li>\n<li>\nEnsure equipment is being operated properly and maintenance issues are reported promptly\n<\/li>\n<li>\nTrain and mentor crew members on safe work practices and operational procedures\n<\/li>\n<li>\nMaintain accurate shift reports, production logs, and incident documentation\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious supervisory experience in mining operations required\n<\/li>\n<li>\nStrong knowledge of surface or underground mining processes (depending on site application)\n<\/li>\n<li>\nExperience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers\n<\/li>\n<li>\nMSHA certification required or ability to obtain\/maintain certification as required by site\n<\/li>\n<li>\nProven leadership, communication, and decision-making skills\n<\/li>\n<li>\nAbility to prioritize tasks and manage multiple crews in a fast-paced environment\n<\/li>\n<li>\nStrong understanding of workplace safety and hazard recognition practices\n<\/li>\n<li>\nProficient in basic reporting, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to work in active mining environments, including exposure to dust, noise, and varying weather conditions\n<\/li>\n<li>\nAbility to walk uneven terrain, climb equipment\/access points, and remain active throughout shift\n<\/li>\n<li>\nAbility to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to wear all required PPE on site<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/371926c51fa0-mining-foreman-traveling","%breezy_id%":"371926c51fa0","%breezy_friendly_id%":"371926c51fa0-mining-foreman-traveling","%breezy_created_date%":"2026-04-15T12:38:44.133Z","%breezy_updated_date%":"2026-05-20T12:52:54.143Z","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Las Vegas, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.171563","%_wpgmp_metabox_longitude%":"-115.1391009","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"247"}},"id":3454,"infowindow_disable":false},{"source":"post","title":"Mining Foreman &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Foreman &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-foreman-6\/\" name=\"Mining Foreman &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;","address":"Winnemucca, NV, USA","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-foreman-6\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety,&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety, and operational excellence. We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nSupervise and direct daily activities of mining crews, equipment operators, and labor personnel\n<\/li>\n<li>\nCoordinate production schedules to meet daily and weekly output targets\n<\/li>\n<li>\nMonitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures\n<\/li>\n<li>\nEnforce mine safety standards, company policies, and MSHA regulations at all times\n<\/li>\n<li>\nConduct pre-shift meetings, safety briefings, and crew assignments\n<\/li>\n<li>\nInspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies\n<\/li>\n<li>\nCommunicate with management regarding production progress, staffing needs, and operational concerns\n<\/li>\n<li>\nEnsure equipment is being operated properly and maintenance issues are reported promptly\n<\/li>\n<li>\nTrain and mentor crew members on safe work practices and operational procedures\n<\/li>\n<li>\nMaintain accurate shift reports, production logs, and incident documentation\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious supervisory experience in mining operations required\n<\/li>\n<li>\nStrong knowledge of surface or underground mining processes (depending on site application)\n<\/li>\n<li>\nExperience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers\n<\/li>\n<li>\nMSHA certification required or ability to obtain\/maintain certification as required by site\n<\/li>\n<li>\nProven leadership, communication, and decision-making skills\n<\/li>\n<li>\nAbility to prioritize tasks and manage multiple crews in a fast-paced environment\n<\/li>\n<li>\nStrong understanding of workplace safety and hazard recognition practices\n<\/li>\n<li>\nProficient in basic reporting, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to work in active mining environments, including exposure to dust, noise, and varying weather conditions\n<\/li>\n<li>\nAbility to walk uneven terrain, climb equipment\/access points, and remain active throughout shift\n<\/li>\n<li>\nAbility to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to wear all required PPE on site<\/li><\/ul>","post_title":"Mining Foreman &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/mining-foreman-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Winnemucca, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group partners with leading mining operations to provide skilled professionals who drive productivity, safety, and operational excellence. We are currently seeking an experienced Mining Foreman to support a mining client by leading daily site operations and supervising crews in a production-focused mining environment.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Mining Foreman is responsible for overseeing day-to-day mining activities, supervising crews, coordinating equipment and labor resources, and ensuring safe and efficient production on site. This leadership role requires strong operational knowledge of mining processes, heavy equipment coordination, and a commitment to maintaining high safety standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nSupervise and direct daily activities of mining crews, equipment operators, and labor personnel\n<\/li>\n<li>\nCoordinate production schedules to meet daily and weekly output targets\n<\/li>\n<li>\nMonitor mining operations to ensure work is completed safely, efficiently, and in compliance with site procedures\n<\/li>\n<li>\nEnforce mine safety standards, company policies, and MSHA regulations at all times\n<\/li>\n<li>\nConduct pre-shift meetings, safety briefings, and crew assignments\n<\/li>\n<li>\nInspect work areas, equipment usage, and operating conditions to identify hazards or inefficiencies\n<\/li>\n<li>\nCommunicate with management regarding production progress, staffing needs, and operational concerns\n<\/li>\n<li>\nEnsure equipment is being operated properly and maintenance issues are reported promptly\n<\/li>\n<li>\nTrain and mentor crew members on safe work practices and operational procedures\n<\/li>\n<li>\nMaintain accurate shift reports, production logs, and incident documentation\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious supervisory experience in mining operations required\n<\/li>\n<li>\nStrong knowledge of surface or underground mining processes (depending on site application)\n<\/li>\n<li>\nExperience managing crews operating heavy mobile equipment such as haul trucks, loaders, excavators, and dozers\n<\/li>\n<li>\nMSHA certification required or ability to obtain\/maintain certification as required by site\n<\/li>\n<li>\nProven leadership, communication, and decision-making skills\n<\/li>\n<li>\nAbility to prioritize tasks and manage multiple crews in a fast-paced environment\n<\/li>\n<li>\nStrong understanding of workplace safety and hazard recognition practices\n<\/li>\n<li>\nProficient in basic reporting, documentation, and production tracking\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to work in active mining environments, including exposure to dust, noise, and varying weather conditions\n<\/li>\n<li>\nAbility to walk uneven terrain, climb equipment\/access points, and remain active throughout shift\n<\/li>\n<li>\nAbility to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to wear all required PPE on site<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/6bdf8040d911-mining-foreman-traveling","%breezy_id%":"6bdf8040d911","%breezy_friendly_id%":"6bdf8040d911-mining-foreman-traveling","%breezy_created_date%":"2026-04-10T18:23:00.763Z","%breezy_updated_date%":"2026-05-27T13:43:35.154Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"246"}},"id":3437,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-11\/\" name=\"Heavy Equipment Operator &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction,&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-11\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction,&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction, and industrial sectors. We are currently seeking experienced Heavy Equipment Operators to support a mining client in a fast-paced production environment. This is an excellent opportunity for safety-focused individuals with mobile equipment experience who are looking to grow their careers in mining operations.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining operations. Equipment may include haul trucks, loaders, excavators, water trucks, dozers, graders, and other production support machinery. Operators play a critical role in maintaining production goals while adhering to strict safety and operational standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nOperate heavy mobile equipment in a safe, efficient, and productive manner\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections and complete required documentation\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions promptly\n<\/li>\n<li>\nFollow mine site safety procedures, policies, and MSHA regulations at all times\n<\/li>\n<li>\nWork closely with supervisors, dispatch, and other team members to meet daily production targets\n<\/li>\n<li>\nMaintain clean and orderly equipment cabs and work areas\n<\/li>\n<li>\nAssist with general mine site tasks as needed to support operations\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating heavy equipment in mining, quarry, construction, or similar industrial environments preferred\n<\/li>\n<li>\nAbility to safely operate one or more types of mobile equipment such as haul trucks, loaders, excavators, or dozers\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong understanding of equipment safety protocols and hazard awareness\n<\/li>\n<li>\nAbility to work in varying weather and site conditions\n<\/li>\n<li>\nReliable transportation and strong attendance record\n<\/li>\n<li>\nAbility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to sit, stand, climb, bend, and walk for extended periods\n<\/li>\n<li>\nAbility to climb in and out of heavy equipment multiple times per shift\n<\/li>\n<li>\nMust be able to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to work in dusty, rugged outdoor environments<\/li><\/ul>","post_title":"Heavy Equipment Operator &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-11\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group is committed to connecting skilled professionals with leading employers in the mining, construction, and industrial sectors. We are currently seeking experienced Heavy Equipment Operators to support a mining client in a fast-paced production environment. This is an excellent opportunity for safety-focused individuals with mobile equipment experience who are looking to grow their careers in mining operations.<\/p>\n<h3>Position Summary<\/h3>\n<p>The Heavy Equipment Operator is responsible for safely operating a variety of mobile heavy equipment used in mining operations. Equipment may include haul trucks, loaders, excavators, water trucks, dozers, graders, and other production support machinery. Operators play a critical role in maintaining production goals while adhering to strict safety and operational standards.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nOperate heavy mobile equipment in a safe, efficient, and productive manner\n<\/li>\n<li>\nPerform pre-shift and post-shift equipment inspections and complete required documentation\n<\/li>\n<li>\nIdentify and report mechanical issues or unsafe conditions promptly\n<\/li>\n<li>\nFollow mine site safety procedures, policies, and MSHA regulations at all times\n<\/li>\n<li>\nWork closely with supervisors, dispatch, and other team members to meet daily production targets\n<\/li>\n<li>\nMaintain clean and orderly equipment cabs and work areas\n<\/li>\n<li>\nAssist with general mine site tasks as needed to support operations\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious experience operating heavy equipment in mining, quarry, construction, or similar industrial environments preferred\n<\/li>\n<li>\nAbility to safely operate one or more types of mobile equipment such as haul trucks, loaders, excavators, or dozers\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong understanding of equipment safety protocols and hazard awareness\n<\/li>\n<li>\nAbility to work in varying weather and site conditions\n<\/li>\n<li>\nReliable transportation and strong attendance record\n<\/li>\n<li>\nAbility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to sit, stand, climb, bend, and walk for extended periods\n<\/li>\n<li>\nAbility to climb in and out of heavy equipment multiple times per shift\n<\/li>\n<li>\nMust be able to lift up to 50 pounds occasionally\n<\/li>\n<li>\nMust be able to work in dusty, rugged outdoor environments<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/1662cd62da14-heavy-equipment-operator-traveling","%breezy_id%":"1662cd62da14","%breezy_friendly_id%":"1662cd62da14-heavy-equipment-operator-traveling","%breezy_created_date%":"2026-04-10T18:11:01.178Z","%breezy_updated_date%":"2026-05-27T13:43:32.030Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"245"}},"id":3433,"infowindow_disable":false},{"source":"post","title":"General Laborer- Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Laborer- Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Turner Staffing Group Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-3\/\" name=\"General Laborer- Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Turner Staffing Group Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations.&hellip;","address":"Winnemucca, NV, USA","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-3\/","zoom":19,"extra_fields":{"post_excerpt":"About Turner Staffing Group Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations.&hellip;","post_content":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations. We are currently seeking motivated General Laborers to support a mining client in a dynamic production environment. This role is ideal for individuals who are safety-conscious, reliable, and eager to work in a hands-on mining setting.<\/p>\n<h3>Position Summary<\/h3>\n<p>The General Laborer is responsible for performing a variety of physical tasks that support daily mining site operations. This role assists equipment operators, maintenance personnel, and site supervisors with general site cleanup, material handling, equipment support, and other labor-intensive duties necessary to keep operations running safely and efficiently.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nPerform general physical labor duties in support of mining operations\n<\/li>\n<li>\nAssist with site cleanup, shoveling, sweeping, and debris removal around work areas\n<\/li>\n<li>\nSupport equipment operators and maintenance crews as needed\n<\/li>\n<li>\nLoad and unload materials, tools, and supplies\n<\/li>\n<li>\nMaintain safe, clean, and organized work areas\n<\/li>\n<li>\nFollow all mine site safety rules, procedures, and MSHA regulations\n<\/li>\n<li>\nIdentify and report unsafe conditions or equipment issues promptly\n<\/li>\n<li>\nUse hand tools and basic equipment safely and effectively\n<\/li>\n<li>\nComplete additional tasks assigned by supervisors to support production needs\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious labor experience in mining, construction, industrial, or outdoor environments preferred\n<\/li>\n<li>\nAbility to perform physically demanding work in rugged outdoor conditions\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong work ethic and willingness to learn\n<\/li>\n<li>\nAbility to follow instructions and work effectively as part of a team\n<\/li>\n<li>\nReliable transportation and dependable attendance required\n<\/li>\n<li>\nFlexibility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to lift, carry, push, and pull up to 50 pounds regularly\n<\/li>\n<li>\nAbility to stand, walk, bend, kneel, stoop, and climb for extended periods\n<\/li>\n<li>\nAbility to work outdoors in varying weather, dust, noise, and uneven terrain\n<\/li>\n<li>\nMust be able to wear required PPE at all times on site<\/li><\/ul>","post_title":"General Laborer- Mining","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Winnemucca, NV","%education%":"Unspecified","%department%":"TSG","%description%":"<h3>About Turner Staffing Group<\/h3>\n<p>Turner Staffing Group connects dependable, hardworking professionals with top employers in mining, construction, and industrial operations. We are currently seeking motivated General Laborers to support a mining client in a dynamic production environment. This role is ideal for individuals who are safety-conscious, reliable, and eager to work in a hands-on mining setting.<\/p>\n<h3>Position Summary<\/h3>\n<p>The General Laborer is responsible for performing a variety of physical tasks that support daily mining site operations. This role assists equipment operators, maintenance personnel, and site supervisors with general site cleanup, material handling, equipment support, and other labor-intensive duties necessary to keep operations running safely and efficiently.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\nPerform general physical labor duties in support of mining operations\n<\/li>\n<li>\nAssist with site cleanup, shoveling, sweeping, and debris removal around work areas\n<\/li>\n<li>\nSupport equipment operators and maintenance crews as needed\n<\/li>\n<li>\nLoad and unload materials, tools, and supplies\n<\/li>\n<li>\nMaintain safe, clean, and organized work areas\n<\/li>\n<li>\nFollow all mine site safety rules, procedures, and MSHA regulations\n<\/li>\n<li>\nIdentify and report unsafe conditions or equipment issues promptly\n<\/li>\n<li>\nUse hand tools and basic equipment safely and effectively\n<\/li>\n<li>\nComplete additional tasks assigned by supervisors to support production needs\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\nPrevious labor experience in mining, construction, industrial, or outdoor environments preferred\n<\/li>\n<li>\nAbility to perform physically demanding work in rugged outdoor conditions\n<\/li>\n<li>\nMSHA certification preferred (or willingness to obtain if required)\n<\/li>\n<li>\nStrong work ethic and willingness to learn\n<\/li>\n<li>\nAbility to follow instructions and work effectively as part of a team\n<\/li>\n<li>\nReliable transportation and dependable attendance required\n<\/li>\n<li>\nFlexibility to work day shift, night shift, weekends, and overtime as needed\n<\/li>\n<\/ul>\n<h3>Physical Requirements<\/h3>\n<ul>\n<li>\nAbility to lift, carry, push, and pull up to 50 pounds regularly\n<\/li>\n<li>\nAbility to stand, walk, bend, kneel, stoop, and climb for extended periods\n<\/li>\n<li>\nAbility to work outdoors in varying weather, dust, noise, and uneven terrain\n<\/li>\n<li>\nMust be able to wear required PPE at all times on site<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/e36166747216-general-laborer-mining","%breezy_id%":"e36166747216","%breezy_friendly_id%":"e36166747216-general-laborer-mining","%breezy_created_date%":"2026-04-10T18:09:46.715Z","%breezy_updated_date%":"2026-05-20T12:49:13.163Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"244"}},"id":3431,"infowindow_disable":false},{"source":"post","title":"Geotechnician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geotechnician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a Lead Geotechnician to support active exploration and mining operations across Nevada (Winnemucca area) and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geotechnician-6\/\" name=\"Geotechnician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a Lead Geotechnician to support active exploration and mining operations across Nevada (Winnemucca area) and&hellip;","address":"Winnemucca, NVUnited States","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geotechnician-6\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a Lead Geotechnician to support active exploration and mining operations across Nevada (Winnemucca area) and&hellip;","post_content":"<p>Turner Staffing Group is seeking a <strong>Lead Geotechnician<\/strong> to support active exploration and mining operations across <strong>Nevada (Winnemucca area) and Southeastern Idaho<\/strong>. This role is a key field leadership position responsible for overseeing geotechnician activities, supporting drilling programs, and ensuring high-quality sample collection and data integrity.<\/p><p>This position offers the opportunity to work across <strong>greenfield through resource stage (RSV) projects<\/strong>, providing exposure to diverse geological environments while leading field execution.<\/p><p><strong><strong>Schedule<\/strong><\/strong><\/p><ul><li><strong>4 days on \/ 3 days off&nbsp;<\/strong><\/li><li>Rotational work across multiple sites <\/li><\/ul><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>The Lead Geotechnician plays a critical role in supporting drilling and exploration programs by overseeing <strong>core handling, sampling, and data collection activities<\/strong>, while ensuring all procedures meet QA\/QC and safety standards.<\/p><p>You will act as a <strong>field lead<\/strong>, coordinating geotechnicians, working closely with geologists and drill crews, and ensuring efficient and accurate execution of daily exploration tasks. <span><br \/><\/span><\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li>Lead and support execution of <strong>drilling and sampling programs<\/strong> <\/li><li>Supervise and train geotechnicians; ensure adherence to SOPs and QA\/QC protocols <\/li><li>Collect and manage geological samples, including blanks, duplicates, and standards <\/li><li>Cut core, prepare samples, and organize shipments to laboratories <\/li><li>Transport, organize, and maintain drill core and sample inventory <\/li><li>Prepare sample bags, chip trays, and documentation for drilling programs <\/li><li>Photograph core, chip trays, and samples as required <\/li><li>Assist with data collection including: <ul><li>Core orientation and recovery (RQD) <\/li><li>Specific gravity measurements and point load testing <\/li><li>GPS collar location collection and database entry <\/li><li>Hyperspectral or pXRF data collection (as applicable) <\/li><\/ul><\/li><li>Maintain core shed organization, safety, and inventory control <\/li><li>Coordinate with geologists, drill crews, and project teams to support drill plans <\/li><li>Identify and communicate operational or safety issues in the field<\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li>Strong experience supporting <strong>drilling and exploration programs<\/strong> <\/li><li>Demonstrated ability to <strong>lead and mentor field technicians<\/strong> <\/li><li>Strong understanding of <strong>sampling methods and QA\/QC procedures<\/strong> <\/li><li>Ability to perform physically demanding work, including lifting <strong>up to 50 lbs regularly<\/strong> <\/li><li>Ability to work in outdoor and remote environments across Nevada and Idaho <\/li><li>Strong attention to detail and organizational skills <\/li><li>Proficiency with <strong>Microsoft Excel and basic data entry systems<\/strong> <\/li><li><strong>Must be authorized to work in the United States without work visa sponsorship<\/strong> <\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li>Associate&rsquo;s degree or coursework in <strong>Geology, Earth Sciences, or related field<\/strong> <\/li><li>Experience with <strong>core handling, RC sampling, and drilling support<\/strong> <\/li><li>Experience operating equipment such as <strong>forklifts, skid steers, or telehandlers<\/strong> <\/li><li>Familiarity with <strong>GPS data collection and geological databases<\/strong> <\/li><li>Experience with pXRF or hyperspectral tools <\/li><li>Prior experience in a <strong>lead or senior technician role<\/strong> <\/li><\/ul><p><strong><strong>Work Environment &amp; Benefits<\/strong><\/strong><\/p><ul><li>Work across <strong>active mine sites and exploration projects<\/strong> <\/li><li>Exposure to diverse geological environments (greenfield through advanced stage) <\/li><li><strong>Per diem and travel support may be available<\/strong> <\/li><li>Potential for <strong>company-provided housing<\/strong> depending on assignment <\/li><li>Opportunity for <strong>extension beyond initial 6-month project<\/strong> <\/li><\/ul><p><strong><strong>Why Join Turner Staffing Group<\/strong><\/strong><\/p><ul><li>Leadership opportunity within active exploration programs <\/li><li>Diverse project exposure across Nevada and Idaho <\/li><li>Hands-on experience supporting drilling and resource development <\/li><li>Strong pathway to advance into geology or supervisory roles <\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are an experienced geotechnician ready to step into a leadership role and contribute to active exploration programs, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","post_title":"Geotechnician","post_link":"https:\/\/turnerstaffing.com\/position\/geotechnician-6\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_city_state%":"Winnemucca, NV","%description%":"<p>Turner Staffing Group is seeking a <strong>Lead Geotechnician<\/strong> to support active exploration and mining operations across <strong>Nevada (Winnemucca area) and Southeastern Idaho<\/strong>. This role is a key field leadership position responsible for overseeing geotechnician activities, supporting drilling programs, and ensuring high-quality sample collection and data integrity.<\/p><p>This position offers the opportunity to work across <strong>greenfield through resource stage (RSV) projects<\/strong>, providing exposure to diverse geological environments while leading field execution.<\/p><p><strong><strong>Schedule<\/strong><\/strong><\/p><ul><li><strong>4 days on \/ 3 days off&nbsp;<\/strong><\/li><li>Rotational work across multiple sites <\/li><\/ul><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>The Lead Geotechnician plays a critical role in supporting drilling and exploration programs by overseeing <strong>core handling, sampling, and data collection activities<\/strong>, while ensuring all procedures meet QA\/QC and safety standards.<\/p><p>You will act as a <strong>field lead<\/strong>, coordinating geotechnicians, working closely with geologists and drill crews, and ensuring efficient and accurate execution of daily exploration tasks. <span><br \/><\/span><\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li>Lead and support execution of <strong>drilling and sampling programs<\/strong> <\/li><li>Supervise and train geotechnicians; ensure adherence to SOPs and QA\/QC protocols <\/li><li>Collect and manage geological samples, including blanks, duplicates, and standards <\/li><li>Cut core, prepare samples, and organize shipments to laboratories <\/li><li>Transport, organize, and maintain drill core and sample inventory <\/li><li>Prepare sample bags, chip trays, and documentation for drilling programs <\/li><li>Photograph core, chip trays, and samples as required <\/li><li>Assist with data collection including: <ul><li>Core orientation and recovery (RQD) <\/li><li>Specific gravity measurements and point load testing <\/li><li>GPS collar location collection and database entry <\/li><li>Hyperspectral or pXRF data collection (as applicable) <\/li><\/ul><\/li><li>Maintain core shed organization, safety, and inventory control <\/li><li>Coordinate with geologists, drill crews, and project teams to support drill plans <\/li><li>Identify and communicate operational or safety issues in the field<\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li>Strong experience supporting <strong>drilling and exploration programs<\/strong> <\/li><li>Demonstrated ability to <strong>lead and mentor field technicians<\/strong> <\/li><li>Strong understanding of <strong>sampling methods and QA\/QC procedures<\/strong> <\/li><li>Ability to perform physically demanding work, including lifting <strong>up to 50 lbs regularly<\/strong> <\/li><li>Ability to work in outdoor and remote environments across Nevada and Idaho <\/li><li>Strong attention to detail and organizational skills <\/li><li>Proficiency with <strong>Microsoft Excel and basic data entry systems<\/strong> <\/li><li><strong>Must be authorized to work in the United States without work visa sponsorship<\/strong> <\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li>Associate&rsquo;s degree or coursework in <strong>Geology, Earth Sciences, or related field<\/strong> <\/li><li>Experience with <strong>core handling, RC sampling, and drilling support<\/strong> <\/li><li>Experience operating equipment such as <strong>forklifts, skid steers, or telehandlers<\/strong> <\/li><li>Familiarity with <strong>GPS data collection and geological databases<\/strong> <\/li><li>Experience with pXRF or hyperspectral tools <\/li><li>Prior experience in a <strong>lead or senior technician role<\/strong> <\/li><\/ul><p><strong><strong>Work Environment &amp; Benefits<\/strong><\/strong><\/p><ul><li>Work across <strong>active mine sites and exploration projects<\/strong> <\/li><li>Exposure to diverse geological environments (greenfield through advanced stage) <\/li><li><strong>Per diem and travel support may be available<\/strong> <\/li><li>Potential for <strong>company-provided housing<\/strong> depending on assignment <\/li><li>Opportunity for <strong>extension beyond initial 6-month project<\/strong> <\/li><\/ul><p><strong><strong>Why Join Turner Staffing Group<\/strong><\/strong><\/p><ul><li>Leadership opportunity within active exploration programs <\/li><li>Diverse project exposure across Nevada and Idaho <\/li><li>Hands-on experience supporting drilling and resource development <\/li><li>Strong pathway to advance into geology or supervisory roles <\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are an experienced geotechnician ready to step into a leadership role and contribute to active exploration programs, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/536cfsumz1iisur1trywb6xkzh","%crelate_id%":"536cfsumz1iisur1trywb6xkzh","%crelate_created_date%":"2026-03-30T18:27:35.97Z","%crelate_updated_date%":"2026-06-05T09:55:10Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NVUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"233"}},"id":3385,"infowindow_disable":false},{"source":"post","title":"Senior Environmental Engineer &#8211; Hydrogeology","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Environmental Engineer &#8211; Hydrogeology\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is recruiting a Senior Environmental Engineer &ndash; Hydrogeology for a direct-hire opportunity with a leading natural resources&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-environmental-engineer-hydrogeology\/\" name=\"Senior Environmental Engineer &#8211; Hydrogeology\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is recruiting a Senior Environmental Engineer &ndash; Hydrogeology for a direct-hire opportunity with a leading natural resources&hellip;","address":"Phoenix, AZUnited States","location":{"lat":"33.4482948","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0725488","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-environmental-engineer-hydrogeology\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is recruiting a Senior Environmental Engineer &ndash; Hydrogeology for a direct-hire opportunity with a leading natural resources&hellip;","post_content":"<p>Turner Staffing Group is recruiting a <strong>Senior Environmental Engineer &ndash; Hydrogeology<\/strong> for a direct-hire opportunity with a leading natural resources organization. This is a high-impact role supporting complex environmental and water management initiatives across large-scale operations.<\/p><p>If you are an experienced environmental engineer with a strong hydrogeologic background and enjoy leading technically challenging projects, this is an opportunity to make a measurable impact while advancing your career.<\/p><p><strong><strong>Why This Opportunity<\/strong><\/strong><\/p><p>You&rsquo;ll be part of a collaborative, safety-driven environment where technical expertise is valued, innovation is encouraged, and professionals are empowered to grow. This role offers the opportunity to work on meaningful environmental projects that directly support operational sustainability and regulatory compliance.<\/p><p><strong><strong>Work Environment<\/strong><\/strong><\/p><ul><li><strong>Hybrid position<\/strong> based in Phoenix, Arizona <\/li><li>Combination of remote work and in-person collaboration <\/li><li>Occasional engagement with operational sites <\/li><li>Flexible, team-oriented work environment with modern collaboration tools <\/li><\/ul><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>Under general supervision, the Senior Environmental Engineer provides technical leadership and project management for environmental and hydrogeologic programs. You will serve as both a <strong>technical expert and project leader<\/strong>, managing complex environmental projects from concept through execution.<\/p><p>This role involves groundwater and surface water investigations, regulatory compliance, environmental risk assessment, and coordination with multidisciplinary teams and external consultants.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li>Lead and manage <strong>environmental water and hydrogeologic projects<\/strong> <\/li><li>Develop scopes of work, Requests for Proposals (RFPs), and oversee consultant selection and performance <\/li><li>Manage project budgets, timelines, and deliverables <\/li><li>Oversee <strong>groundwater and surface water investigations<\/strong> and hydrogeologic assessments <\/li><li>Develop and review <strong>flow and transport modeling<\/strong> for permitting and regulatory requirements <\/li><li>Manage environmental data systems, including <strong>EQuIS<\/strong>, for data integration and reporting <\/li><li>Evaluate environmental impacts related to facility changes, expansions, or closures <\/li><li>Prepare and maintain regulatory documentation and technical reports <\/li><li>Ensure compliance with applicable regulations (CERCLA, NEPA, SARA, Clean Air\/Water Acts) <\/li><li>Provide leadership and technical guidance to engineers and technical staff <\/li><li>Present technical findings and recommendations to stakeholders<\/li><li>Other duties as assigned.<\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li>Bachelor&rsquo;s degree in <strong>Engineering<\/strong> (Environmental, Civil, Chemical, Geological, Mining, or related field) <strong>and 5+ years of experience<\/strong><br \/><strong>OR<\/strong> <\/li><li>Master&rsquo;s degree in a related field and <strong>3+ years of experience<\/strong> <\/li><li>Experience in <strong>environmental management and project management<\/strong> <\/li><li>Strong knowledge of environmental compliance, permitting, and reporting <\/li><li>Proven ability to manage <strong>large, complex environmental projects<\/strong> <\/li><li>Strong analytical skills and ability to interpret environmental data <\/li><li>Excellent written and verbal communication skills <\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li>Experience with <strong>EQuIS or similar environmental data systems<\/strong> <\/li><li>Experience with <strong>water permitting and compliance<\/strong> in Arizona, Colorado, or New Mexico <\/li><li>Certifications such as <strong>HAZWOPER, CHMM, or similar<\/strong> <\/li><li>Experience in mining, industrial, or heavy industry environments <\/li><li>Ability to work independently and within multidisciplinary teams <\/li><\/ul><p><strong><strong>Benefits<\/strong><\/strong><\/p><ul><li>Bonus and incentive opportunities based on performance <\/li><li>Comprehensive benefits package, including: <ul><li>Medical, dental, and vision coverage <\/li><li>Company-paid life and disability insurance <\/li><li>401(k) with employer match <\/li><li>Paid time off and holidays <\/li><li>Tuition assistance <\/li><li>Employee assistance programs <\/li><li>Additional insurance and discount programs <\/li><\/ul><\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are a technically strong environmental engineer looking to lead impactful hydrogeologic projects in a collaborative and growth-oriented environment, we encourage you to apply.<strong><\/strong><\/p>","post_title":"Senior Environmental Engineer &#8211; Hydrogeology","post_link":"https:\/\/turnerstaffing.com\/position\/senior-environmental-engineer-hydrogeology\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_city_state%":"Phoenix, AZ","%description%":"<p>Turner Staffing Group is recruiting a <strong>Senior Environmental Engineer &ndash; Hydrogeology<\/strong> for a direct-hire opportunity with a leading natural resources organization. This is a high-impact role supporting complex environmental and water management initiatives across large-scale operations.<\/p><p>If you are an experienced environmental engineer with a strong hydrogeologic background and enjoy leading technically challenging projects, this is an opportunity to make a measurable impact while advancing your career.<\/p><p><strong><strong>Why This Opportunity<\/strong><\/strong><\/p><p>You&rsquo;ll be part of a collaborative, safety-driven environment where technical expertise is valued, innovation is encouraged, and professionals are empowered to grow. This role offers the opportunity to work on meaningful environmental projects that directly support operational sustainability and regulatory compliance.<\/p><p><strong><strong>Work Environment<\/strong><\/strong><\/p><ul><li><strong>Hybrid position<\/strong> based in Phoenix, Arizona <\/li><li>Combination of remote work and in-person collaboration <\/li><li>Occasional engagement with operational sites <\/li><li>Flexible, team-oriented work environment with modern collaboration tools <\/li><\/ul><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>Under general supervision, the Senior Environmental Engineer provides technical leadership and project management for environmental and hydrogeologic programs. You will serve as both a <strong>technical expert and project leader<\/strong>, managing complex environmental projects from concept through execution.<\/p><p>This role involves groundwater and surface water investigations, regulatory compliance, environmental risk assessment, and coordination with multidisciplinary teams and external consultants.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li>Lead and manage <strong>environmental water and hydrogeologic projects<\/strong> <\/li><li>Develop scopes of work, Requests for Proposals (RFPs), and oversee consultant selection and performance <\/li><li>Manage project budgets, timelines, and deliverables <\/li><li>Oversee <strong>groundwater and surface water investigations<\/strong> and hydrogeologic assessments <\/li><li>Develop and review <strong>flow and transport modeling<\/strong> for permitting and regulatory requirements <\/li><li>Manage environmental data systems, including <strong>EQuIS<\/strong>, for data integration and reporting <\/li><li>Evaluate environmental impacts related to facility changes, expansions, or closures <\/li><li>Prepare and maintain regulatory documentation and technical reports <\/li><li>Ensure compliance with applicable regulations (CERCLA, NEPA, SARA, Clean Air\/Water Acts) <\/li><li>Provide leadership and technical guidance to engineers and technical staff <\/li><li>Present technical findings and recommendations to stakeholders<\/li><li>Other duties as assigned.<\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li>Bachelor&rsquo;s degree in <strong>Engineering<\/strong> (Environmental, Civil, Chemical, Geological, Mining, or related field) <strong>and 5+ years of experience<\/strong><br \/><strong>OR<\/strong> <\/li><li>Master&rsquo;s degree in a related field and <strong>3+ years of experience<\/strong> <\/li><li>Experience in <strong>environmental management and project management<\/strong> <\/li><li>Strong knowledge of environmental compliance, permitting, and reporting <\/li><li>Proven ability to manage <strong>large, complex environmental projects<\/strong> <\/li><li>Strong analytical skills and ability to interpret environmental data <\/li><li>Excellent written and verbal communication skills <\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li>Experience with <strong>EQuIS or similar environmental data systems<\/strong> <\/li><li>Experience with <strong>water permitting and compliance<\/strong> in Arizona, Colorado, or New Mexico <\/li><li>Certifications such as <strong>HAZWOPER, CHMM, or similar<\/strong> <\/li><li>Experience in mining, industrial, or heavy industry environments <\/li><li>Ability to work independently and within multidisciplinary teams <\/li><\/ul><p><strong><strong>Benefits<\/strong><\/strong><\/p><ul><li>Bonus and incentive opportunities based on performance <\/li><li>Comprehensive benefits package, including: <ul><li>Medical, dental, and vision coverage <\/li><li>Company-paid life and disability insurance <\/li><li>401(k) with employer match <\/li><li>Paid time off and holidays <\/li><li>Tuition assistance <\/li><li>Employee assistance programs <\/li><li>Additional insurance and discount programs <\/li><\/ul><\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are a technically strong environmental engineer looking to lead impactful hydrogeologic projects in a collaborative and growth-oriented environment, we encourage you to apply.<strong><\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/ury6fpxbndd77wdxaptm9igy9e","%crelate_id%":"ury6fpxbndd77wdxaptm9igy9e","%crelate_created_date%":"2026-03-24T13:41:36.34Z","%crelate_updated_date%":"2026-05-26T22:46:52.11Z","%_wpgmp_location_city%":"Phoenix","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Phoenix, AZUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4482948","%_wpgmp_metabox_longitude%":"-112.0725488","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"235"}},"id":3346,"infowindow_disable":false},{"source":"post","title":"Geology Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geology Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is recruiting a Geology Superintendent for an on-site, project-based leadership opportunity with a mining operation in Nevada.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geology-superintendent\/\" name=\"Geology Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is recruiting a Geology Superintendent for an on-site, project-based leadership opportunity with a mining operation in Nevada.&hellip;","address":"Elko, NVUnited States","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geology-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is recruiting a Geology Superintendent for an on-site, project-based leadership opportunity with a mining operation in Nevada.&hellip;","post_content":"<p>Turner Staffing Group is recruiting a <strong>Geology Superintendent<\/strong> for an on-site, project-based leadership opportunity with a mining operation in Nevada. This is a high-impact role responsible for leading all geological functions across exploration, study, and future operational phases of the project.<\/p><p>This position is ideal for a senior geologist who combines <strong>strong technical expertise, leadership capability, and operational understanding<\/strong>, and who is motivated to drive both <strong>resource growth and operational excellence<\/strong>.<\/p><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>The Geology Superintendent will lead the site geology function, ensuring accurate and timely orebody knowledge supports safe, efficient, and sustainable mining operations. This role spans the full lifecycle of geological work, including <strong>operational geology, grade control, geological modeling, resource estimation, drilling programs, and data management<\/strong>.<\/p><p>You will play a critical role in aligning geological insights with mine planning, production, and long-term strategy&mdash;helping guide the project from <strong>study phase into operational execution<\/strong>.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><p><strong>Technical Leadership &amp; Operational Geology<\/strong><\/p><ul><li><p>Lead all geological activities including <strong>mapping, sampling, logging, ore control, and reconciliation<\/strong><\/p><\/li><li><p>Integrate geological understanding into <strong>mine planning, production decisions, and risk management<\/strong><\/p><\/li><li><p>Oversee geological modeling, resource estimation, and database management systems<\/p><\/li><li><p>Interpret and communicate key geological insights such as <strong>structure, grade trends, alteration, and geometallurgical controls<\/strong><\/p><\/li><li><p>Ensure robust <strong>QA\/QC processes<\/strong> and continuous improvement of geological workflows<\/p><\/li><\/ul><p><strong>Drilling &amp; Resource Development<\/strong><\/p><ul><li><p>Lead planning and execution of <strong>production, infill, near-mine, and exploration drilling programs<\/strong><\/p><\/li><li><p>Develop drilling strategies aligned with both operational and long-term resource objectives<\/p><\/li><li><p>Manage drill budgets, proposals, and capital planning<\/p><\/li><li><p>Support exploration targeting and resource growth initiatives<\/p><\/li><\/ul><p><strong>Leadership &amp; Management<\/strong><\/p><ul><li><p>Lead, mentor, and develop the geology team, including succession planning and performance management<\/p><\/li><li><p>Manage departmental budgets, forecasts, and cost control<\/p><\/li><li><p>Oversee consultants, contractors, and vendors<\/p><\/li><li><p>Establish strong cross-functional partnerships with engineering, operations, processing, and environmental teams<\/p><\/li><li><p>Track and deliver on KPIs, ensuring timely execution of models, reports, and operational support<\/p><\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><p>Bachelor&rsquo;s degree in <strong>Geology, Geological Engineering, or related field<\/strong> (Master&rsquo;s preferred)<\/p><\/li><li><p><strong>10+ years of experience<\/strong> in mining geology, including <strong>5+ years in a leadership role<\/strong><\/p><\/li><li><p>Strong experience in <strong>geological modeling and resource estimation<\/strong><\/p><\/li><li><p>Proficiency with tools such as <strong>Leapfrog and mining software platforms<\/strong><\/p><\/li><li><p>Experience in both <strong>open-pit and underground mining environments<\/strong><\/p><\/li><li><p>Experience managing <strong>drilling programs and exploration campaigns<\/strong><\/p><\/li><li><p>Ability to operate at both <strong>strategic and operational levels<\/strong><\/p><\/li><li><p>Strong leadership, communication, and team development skills<\/p><\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li><p>Ability to sign off as a <strong>NI 43-101 Qualified Person (QP)<\/strong><\/p><\/li><li><p>Experience in district-scale and near-mine exploration<\/p><\/li><li><p>Experience supporting projects transitioning from <strong>study to operations<\/strong><\/p><\/li><li><p>Strong background in geometallurgy and reconciliation practices<\/p><\/li><\/ul><p><strong><strong>Work Environment<\/strong><\/strong><\/p><ul><li><p>Active mining and exploration environment<\/p><\/li><li><p>Combination of <strong>field leadership, technical work, and strategic planning<\/strong><\/p><\/li><li><p>High-visibility role interacting with site leadership and corporate teams<\/p><\/li><\/ul><p><strong><strong>Why This Opportunity<\/strong><\/strong><\/p><ul><li><p>Senior leadership role with <strong>direct impact on project success and future operations<\/strong><\/p><\/li><li><p>Opportunity to shape geological strategy from <strong>study phase through production<\/strong><\/p><\/li><li><p>Lead and develop a high-performing technical team<\/p><\/li><li><p>Competitive compensation and long-term career potential<\/p><\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are a senior geology leader ready to take ownership of a critical technical function and drive both operational and strategic success, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","post_title":"Geology Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/geology-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_city_state%":"Elko, NV","%description%":"<p>Turner Staffing Group is recruiting a <strong>Geology Superintendent<\/strong> for an on-site, project-based leadership opportunity with a mining operation in Nevada. This is a high-impact role responsible for leading all geological functions across exploration, study, and future operational phases of the project.<\/p><p>This position is ideal for a senior geologist who combines <strong>strong technical expertise, leadership capability, and operational understanding<\/strong>, and who is motivated to drive both <strong>resource growth and operational excellence<\/strong>.<\/p><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>The Geology Superintendent will lead the site geology function, ensuring accurate and timely orebody knowledge supports safe, efficient, and sustainable mining operations. This role spans the full lifecycle of geological work, including <strong>operational geology, grade control, geological modeling, resource estimation, drilling programs, and data management<\/strong>.<\/p><p>You will play a critical role in aligning geological insights with mine planning, production, and long-term strategy&mdash;helping guide the project from <strong>study phase into operational execution<\/strong>.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><p><strong>Technical Leadership &amp; Operational Geology<\/strong><\/p><ul><li><p>Lead all geological activities including <strong>mapping, sampling, logging, ore control, and reconciliation<\/strong><\/p><\/li><li><p>Integrate geological understanding into <strong>mine planning, production decisions, and risk management<\/strong><\/p><\/li><li><p>Oversee geological modeling, resource estimation, and database management systems<\/p><\/li><li><p>Interpret and communicate key geological insights such as <strong>structure, grade trends, alteration, and geometallurgical controls<\/strong><\/p><\/li><li><p>Ensure robust <strong>QA\/QC processes<\/strong> and continuous improvement of geological workflows<\/p><\/li><\/ul><p><strong>Drilling &amp; Resource Development<\/strong><\/p><ul><li><p>Lead planning and execution of <strong>production, infill, near-mine, and exploration drilling programs<\/strong><\/p><\/li><li><p>Develop drilling strategies aligned with both operational and long-term resource objectives<\/p><\/li><li><p>Manage drill budgets, proposals, and capital planning<\/p><\/li><li><p>Support exploration targeting and resource growth initiatives<\/p><\/li><\/ul><p><strong>Leadership &amp; Management<\/strong><\/p><ul><li><p>Lead, mentor, and develop the geology team, including succession planning and performance management<\/p><\/li><li><p>Manage departmental budgets, forecasts, and cost control<\/p><\/li><li><p>Oversee consultants, contractors, and vendors<\/p><\/li><li><p>Establish strong cross-functional partnerships with engineering, operations, processing, and environmental teams<\/p><\/li><li><p>Track and deliver on KPIs, ensuring timely execution of models, reports, and operational support<\/p><\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><p>Bachelor&rsquo;s degree in <strong>Geology, Geological Engineering, or related field<\/strong> (Master&rsquo;s preferred)<\/p><\/li><li><p><strong>10+ years of experience<\/strong> in mining geology, including <strong>5+ years in a leadership role<\/strong><\/p><\/li><li><p>Strong experience in <strong>geological modeling and resource estimation<\/strong><\/p><\/li><li><p>Proficiency with tools such as <strong>Leapfrog and mining software platforms<\/strong><\/p><\/li><li><p>Experience in both <strong>open-pit and underground mining environments<\/strong><\/p><\/li><li><p>Experience managing <strong>drilling programs and exploration campaigns<\/strong><\/p><\/li><li><p>Ability to operate at both <strong>strategic and operational levels<\/strong><\/p><\/li><li><p>Strong leadership, communication, and team development skills<\/p><\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li><p>Ability to sign off as a <strong>NI 43-101 Qualified Person (QP)<\/strong><\/p><\/li><li><p>Experience in district-scale and near-mine exploration<\/p><\/li><li><p>Experience supporting projects transitioning from <strong>study to operations<\/strong><\/p><\/li><li><p>Strong background in geometallurgy and reconciliation practices<\/p><\/li><\/ul><p><strong><strong>Work Environment<\/strong><\/strong><\/p><ul><li><p>Active mining and exploration environment<\/p><\/li><li><p>Combination of <strong>field leadership, technical work, and strategic planning<\/strong><\/p><\/li><li><p>High-visibility role interacting with site leadership and corporate teams<\/p><\/li><\/ul><p><strong><strong>Why This Opportunity<\/strong><\/strong><\/p><ul><li><p>Senior leadership role with <strong>direct impact on project success and future operations<\/strong><\/p><\/li><li><p>Opportunity to shape geological strategy from <strong>study phase through production<\/strong><\/p><\/li><li><p>Lead and develop a high-performing technical team<\/p><\/li><li><p>Competitive compensation and long-term career potential<\/p><\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are a senior geology leader ready to take ownership of a critical technical function and drive both operational and strategic success, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/uks9f756dp71rhmemd5g8xub9a","%crelate_id%":"uks9f756dp71rhmemd5g8xub9a","%crelate_created_date%":"2026-03-23T15:04:22.74Z","%crelate_updated_date%":"2026-05-26T22:45:26.1Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NVUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"237"}},"id":3339,"infowindow_disable":false},{"source":"post","title":"Project Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Project Geologist will be responsible for planning, executing, and interpreting drilling programs to support resource growth and project development.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-geologist-2\/\" name=\"Project Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Project Geologist will be responsible for planning, executing, and interpreting drilling programs to support resource growth and project development.&hellip;","address":"Elko, NVUnited States","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-geologist-2\/","zoom":19,"extra_fields":{"post_excerpt":"The Project Geologist will be responsible for planning, executing, and interpreting drilling programs to support resource growth and project development.&hellip;","post_content":"<p style=\"color:#222222\">The Project Geologist will be responsible for planning, executing, and interpreting drilling programs to support resource growth and project development. This role works closely with geology, technical services, and operations teams to ensure accurate data collection, safe execution, and high-quality geological interpretation.<\/p><p style=\"color:#222222\">You will lead field programs from target generation through drilling execution and data interpretation, ensuring that all geological, geochemical, and spatial data are collected and integrated effectively to support decision-making.<\/p><p style=\"color:#222222\">The schedule is 8 days on\/6 days off.<\/p><p style=\"color:#222222\"><strong>Key Responsibilities<\/strong><\/p><ul><li><p>Lead and support surface and underground drilling programs from planning through execution<\/p><\/li><li><p>Ensure accurate geological logging, sampling, and data collection for drill programs<\/p><\/li><li><p>Supervise and coordinate drilling contractors, vendors, and field teams<\/p><\/li><li><p>Develop and refine geological models to support resource definition and exploration targeting<\/p><\/li><li><p>Conduct geological mapping and sampling programs, including rock, soil, and structural mapping<\/p><\/li><li><p>Manage sample preparation, submission, and assay tracking<\/p><\/li><li><p>Implement and maintain QA\/QC protocols to ensure data quality and integrity<\/p><\/li><li><p>Analyze and interpret geological, geochemical, and drilling data<\/p><\/li><li><p>Utilize software tools (e.g., Leapfrog or similar) to generate models, sections, and reports<\/p><\/li><li><p>Support exploration targeting and contribute to technical decision-making<\/p><\/li><li><p>Provide regular updates and communicate results to internal stakeholders<\/p><\/li><li><p>Promote a strong culture of safety, environmental stewardship, and operational excellence <\/p><\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p style=\"color:#222222\"><strong>Required Qualifications<\/strong><\/p><ul><li><p>Bachelor of Science in Geology or related field<\/p><\/li><li><p>5+ years of experience in mineral exploration or mine geology<\/p><\/li><li><p>Experience in underground mining operations<\/p><\/li><li><p>Hands-on experience with drilling programs and geological data collection<\/p><\/li><li><p>Strong understanding of geological logging, sampling, and QA\/QC procedures<\/p><\/li><li><p>Ability to work in both surface and underground environments<\/p><\/li><li><p>Strong communication and organizational skills<\/p><\/li><li><p>Must be authorized to work in the US without work visa sponsorship<\/p><\/li><\/ul><p style=\"color:#222222\"><strong>Preferred Qualifications<\/strong><\/p><ul><li><p>Experience working in active exploration or mining operations<\/p><\/li><li><p>Experience in surface mining operations<\/p><\/li><li><p>Experience with Leapfrog or similar geological modeling software<\/p><\/li><li><p>Experience with geological databases and data management systems<\/p><\/li><li><p>Strong understanding of mineral systems and exploration targeting<\/p><\/li><\/ul><p style=\"color:#222222\"><strong>Work Environment<\/strong><\/p><ul><li><p>Active mining and exploration site<\/p><\/li><li><p>Combination of fieldwork, drill site supervision, and technical analysis<\/p><\/li><li><p>Work in variable terrain and weather conditions<\/p><\/li><li><p>Hands-on, team-oriented environment with strong collaboration across disciplines<\/p><\/li><\/ul><p style=\"color:#222222\"><strong>Why Join Turner Staffing Group?<\/strong><\/p><ul><li><p>Long-term project with strong continuity and impact<\/p><\/li><li><p>Opportunity to lead and influence active exploration programs<\/p><\/li><li><p>Work on a technically meaningful project in a well-established mining district<\/p><\/li><li><p>Competitive compensation and rotational schedule<\/p><\/li><\/ul><p style=\"color:#222222\"><strong>Apply Today<\/strong><\/p><p style=\"color:#222222\">If you are a motivated geologist with strong field and drilling experience looking to take ownership of exploration programs, we encourage you to apply.<\/p><p style=\"color:#222222\">Turner Staffing Group is an equal opportunity employer.<\/p>","post_title":"Project Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/project-geologist-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_city_state%":"Elko, NV","%description%":"<p style=\"color:#222222;\">The Project Geologist will be responsible for planning, executing, and interpreting drilling programs to support resource growth and project development. This role works closely with geology, technical services, and operations teams to ensure accurate data collection, safe execution, and high-quality geological interpretation.<\/p><p style=\"color:#222222;\">You will lead field programs from target generation through drilling execution and data interpretation, ensuring that all geological, geochemical, and spatial data are collected and integrated effectively to support decision-making.<\/p><p style=\"color:#222222;\">The schedule is 8 days on\/6 days off.<\/p><p style=\"color:#222222;\"><strong>Key Responsibilities<\/strong><\/p><ul><li><p>Lead and support surface and underground drilling programs from planning through execution<\/p><\/li><li><p>Ensure accurate geological logging, sampling, and data collection for drill programs<\/p><\/li><li><p>Supervise and coordinate drilling contractors, vendors, and field teams<\/p><\/li><li><p>Develop and refine geological models to support resource definition and exploration targeting<\/p><\/li><li><p>Conduct geological mapping and sampling programs, including rock, soil, and structural mapping<\/p><\/li><li><p>Manage sample preparation, submission, and assay tracking<\/p><\/li><li><p>Implement and maintain QA\/QC protocols to ensure data quality and integrity<\/p><\/li><li><p>Analyze and interpret geological, geochemical, and drilling data<\/p><\/li><li><p>Utilize software tools (e.g., Leapfrog or similar) to generate models, sections, and reports<\/p><\/li><li><p>Support exploration targeting and contribute to technical decision-making<\/p><\/li><li><p>Provide regular updates and communicate results to internal stakeholders<\/p><\/li><li><p>Promote a strong culture of safety, environmental stewardship, and operational excellence <\/p><\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p style=\"color:#222222;\"><strong>Required Qualifications<\/strong><\/p><ul><li><p>Bachelor of Science in Geology or related field<\/p><\/li><li><p>5+ years of experience in mineral exploration or mine geology<\/p><\/li><li><p>Experience in underground mining operations<\/p><\/li><li><p>Hands-on experience with drilling programs and geological data collection<\/p><\/li><li><p>Strong understanding of geological logging, sampling, and QA\/QC procedures<\/p><\/li><li><p>Ability to work in both surface and underground environments<\/p><\/li><li><p>Strong communication and organizational skills<\/p><\/li><li><p>Must be authorized to work in the US without work visa sponsorship<\/p><\/li><\/ul><p style=\"color:#222222;\"><strong>Preferred Qualifications<\/strong><\/p><ul><li><p>Experience working in active exploration or mining operations<\/p><\/li><li><p>Experience in surface mining operations<\/p><\/li><li><p>Experience with Leapfrog or similar geological modeling software<\/p><\/li><li><p>Experience with geological databases and data management systems<\/p><\/li><li><p>Strong understanding of mineral systems and exploration targeting<\/p><\/li><\/ul><p style=\"color:#222222;\"><strong>Work Environment<\/strong><\/p><ul><li><p>Active mining and exploration site<\/p><\/li><li><p>Combination of fieldwork, drill site supervision, and technical analysis<\/p><\/li><li><p>Work in variable terrain and weather conditions<\/p><\/li><li><p>Hands-on, team-oriented environment with strong collaboration across disciplines<\/p><\/li><\/ul><p style=\"color:#222222;\"><strong>Why Join Turner Staffing Group?<\/strong><\/p><ul><li><p>Long-term project with strong continuity and impact<\/p><\/li><li><p>Opportunity to lead and influence active exploration programs<\/p><\/li><li><p>Work on a technically meaningful project in a well-established mining district<\/p><\/li><li><p>Competitive compensation and rotational schedule<\/p><\/li><\/ul><p style=\"color:#222222;\"><strong>Apply Today<\/strong><\/p><p style=\"color:#222222;\">If you are a motivated geologist with strong field and drilling experience looking to take ownership of exploration programs, we encourage you to apply.<\/p><p style=\"color:#222222;\">Turner Staffing Group is an equal opportunity employer.<\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/yq8qmcty3faw7wkryzufxsm3me","%crelate_id%":"yq8qmcty3faw7wkryzufxsm3me","%crelate_created_date%":"2026-03-20T16:16:28.65Z","%crelate_updated_date%":"2026-05-28T11:44:27.61Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NVUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"231"}},"id":3331,"infowindow_disable":false},{"source":"post","title":"Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a Geologist to support a short-term exploration and technical geology project for one of our&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist-11\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a Geologist to support a short-term exploration and technical geology project for one of our&hellip;","address":"Battle Mountain, NVUnited States","location":{"lat":"40.6421334","city":"Battle Mountain","state":"NV","country":"United States","lng":"-116.9342671","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist-11\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a Geologist to support a short-term exploration and technical geology project for one of our&hellip;","post_content":"<p><strong><\/strong>Turner Staffing Group is seeking a <strong>Geologist<\/strong> to support a short-term exploration and technical geology project for one of our <strong>mining industry clients<\/strong> in the <strong>Elko, Nevada<\/strong> area. This is an <strong>on-site, project-based<\/strong> opportunity ideal for geologists looking to apply their academic foundation and technical skills in an active mining environment.<\/p><p><strong><strong>Role Overview<\/strong><\/strong><\/p><p>The Geologist will support geological analysis, data collection, and technical documentation related to mineral exploration and project evaluation. This role involves working closely with technical teams to interpret geological data and contribute to project outcomes.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li><p>Support geological logging, sampling, and analysis activities<\/p><\/li><li><p>Interpret mineralogical and geological data related to exploration programs<\/p><\/li><li><p>Assist with data entry, validation, and management within geological databases<\/p><\/li><li><p>Collaborate with senior geologists and technical teams on geological interpretations<\/p><\/li><li><p>Contribute to project documentation and reporting<\/p><\/li><li><p>Follow all site safety procedures and field protocols<\/p><\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><p>Bachelor of Science in <strong>Geology<\/strong>, <strong>Engineering Geology<\/strong>, or <strong>Geochemistry<\/strong><\/p><\/li><li><p>Completion of an <strong>undergraduate mineralogy course with a laboratory component<\/strong><\/p><\/li><li><p>Completion of an <strong>economic geology course<\/strong><\/p><\/li><li><p>Strong attention to detail and ability to work in a technical, data-driven environment<\/p><\/li><li><p>Must be authorized to work in the U.S. without visa sponsorship<\/p><\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li><p>Experience with <strong>skarn and porphyry geology<\/strong><\/p><\/li><li><p>Familiarity with <strong>hydrothermal alteration systems<\/strong><\/p><\/li><li><p>Experience with <strong>Acquire<\/strong> or similar geological data management systems<\/p><\/li><li><p>Prior exposure to mining or exploration environments<\/p><\/li><\/ul><p><strong><strong>Why Work With Turner Staffing Group<\/strong><\/strong><\/p><ul><li><p>Opportunity to gain hands-on experience in an active mining project<\/p><\/li><li><p>Work in a collaborative, technical team environment<\/p><\/li><li><p>Exposure to real-world application of academic geology training<\/p><\/li><li><p>Competitive compensation for a project-based role<\/p><\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you have a strong academic foundation in geology and are eager to apply your skills on a real-world project, we encourage you to apply.<strong><\/strong><\/p>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist-11\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Battle Mountain","%location_state_id%":"NV","%location_city_state%":"Battle Mountain, NV","%description%":"<p><strong><\/strong>Turner Staffing Group is seeking a <strong>Geologist<\/strong> to support a short-term exploration and technical geology project for one of our <strong>mining industry clients<\/strong> in the <strong>Elko, Nevada<\/strong> area. This is an <strong>on-site, project-based<\/strong> opportunity ideal for geologists looking to apply their academic foundation and technical skills in an active mining environment.<\/p><p><strong><strong>Role Overview<\/strong><\/strong><\/p><p>The Geologist will support geological analysis, data collection, and technical documentation related to mineral exploration and project evaluation. This role involves working closely with technical teams to interpret geological data and contribute to project outcomes.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li><p>Support geological logging, sampling, and analysis activities<\/p><\/li><li><p>Interpret mineralogical and geological data related to exploration programs<\/p><\/li><li><p>Assist with data entry, validation, and management within geological databases<\/p><\/li><li><p>Collaborate with senior geologists and technical teams on geological interpretations<\/p><\/li><li><p>Contribute to project documentation and reporting<\/p><\/li><li><p>Follow all site safety procedures and field protocols<\/p><\/li><li><p>Other duties as assigned.<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><p>Bachelor of Science in <strong>Geology<\/strong>, <strong>Engineering Geology<\/strong>, or <strong>Geochemistry<\/strong><\/p><\/li><li><p>Completion of an <strong>undergraduate mineralogy course with a laboratory component<\/strong><\/p><\/li><li><p>Completion of an <strong>economic geology course<\/strong><\/p><\/li><li><p>Strong attention to detail and ability to work in a technical, data-driven environment<\/p><\/li><li><p>Must be authorized to work in the U.S. without visa sponsorship<\/p><\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li><p>Experience with <strong>skarn and porphyry geology<\/strong><\/p><\/li><li><p>Familiarity with <strong>hydrothermal alteration systems<\/strong><\/p><\/li><li><p>Experience with <strong>Acquire<\/strong> or similar geological data management systems<\/p><\/li><li><p>Prior exposure to mining or exploration environments<\/p><\/li><\/ul><p><strong><strong>Why Work With Turner Staffing Group<\/strong><\/strong><\/p><ul><li><p>Opportunity to gain hands-on experience in an active mining project<\/p><\/li><li><p>Work in a collaborative, technical team environment<\/p><\/li><li><p>Exposure to real-world application of academic geology training<\/p><\/li><li><p>Competitive compensation for a project-based role<\/p><\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you have a strong academic foundation in geology and are eager to apply your skills on a real-world project, we encourage you to apply.<strong><\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/r9cfbzqr9cnf1ygimbgb4fn4fh","%crelate_id%":"r9cfbzqr9cnf1ygimbgb4fn4fh","%crelate_created_date%":"2026-02-03T17:03:55.12Z","%crelate_updated_date%":"2026-06-04T14:14:41.51Z","%_wpgmp_location_city%":"Battle Mountain","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Battle Mountain, NVUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.6421334","%_wpgmp_metabox_longitude%":"-116.9342671","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"207"}},"id":3300,"infowindow_disable":false},{"source":"post","title":"Chief Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Chief Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Chief Geologist leads all mine-site geological activities for a high-tonnage open-pit, Cu-porphyry-skarn, processing sulfide ore by flotation. Emphasis is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/chief-geologist-2\/\" name=\"Chief Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Chief Geologist leads all mine-site geological activities for a high-tonnage open-pit, Cu-porphyry-skarn, processing sulfide ore by flotation. Emphasis is&hellip;","address":"Sahuarita, AZUnited States","location":{"lat":"31.9575818","city":"Sahuarita","state":"AZ","country":"United States","lng":"-110.955646","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/chief-geologist-2\/","zoom":19,"extra_fields":{"post_excerpt":"The Chief Geologist leads all mine-site geological activities for a high-tonnage open-pit, Cu-porphyry-skarn, processing sulfide ore by flotation. Emphasis is&hellip;","post_content":"<p style=\"color:#595959\">The Chief Geologist leads all mine-site geological activities for a high-tonnage open-pit, Cu-porphyry-skarn, processing sulfide ore by flotation. Emphasis is on short-range grade control and ore routing, geometallurgical domaining, resource growth, rigorous data collection\/QAQC, and timely geological inputs to mine planning. The role reports to the Technical Services Manager and collaborates closely with the Corporate Technical Team and Corporate Resource Manager. The position operates with minimal supervision, exercises sound professional judgment, and demonstrates visible leadership in safety, environmental stewardship, and cross-functional teamwork with Operations, Planning, Geotechnical, Hydrogeology, and Metallurgy.<\/p><p style=\"color:#595959\">Duties &amp; Responsibilities:<\/p><ul><li>Lead and supervise the Mine Geology and Ore Control teams (geologists, technicians, samplers); ensure contemporary training, competency, and an inclusive, high-performance culture<\/li><li>Oversee daily geological mapping, sampling, and logging- capturing lithology, structure, alteration, and mineralization at appropriate scales for ore control and reconciliation.<\/li><li>Own short-range ore control: manage blasthole sampling and assay QAQC (CRMs, blanks, duplicates), blast-movement correction, and generation of clean dig polygons and grade control models; differentiate mill (sulfide) vs. blend vs. waste as required.<\/li><li>Integrate pit mapping, drilling, and survey data into the Leapfrog Geo 3-D model (with Seequent Central or equivalent) to maintain current, auditable interpretations for dispatch, short-range, and mid\/long-range plans.<\/li><li>Collaborate with Mine Engineering (Hexagon MinePlan\/MineSight) to deliver reliable geological constraints for short-, mid-, and life-of-mine plans; steward density models and dilution\/loss assumptions.<\/li><li>Lead grade reconciliation (daily\/weekly\/monthly): ore control vs. plant vs. resource model (tonnage, grade, metal, spatial); diagnose variances and adjust domaining, parameters, or practices accordingly.<\/li><li>Coordinate drill programs&mdash;infill, metallurgical, condemnation, and exploration&mdash;including design, supervision, sampling, chain-of-custody, laboratory interfaces, and full QAQC adherence.<\/li><li>Partner with Metallurgy to define geometallurgical domains controlling throughput, recovery, reagent consumption, and concentrate quality and support blending and Mine-to-Mill strategies.<\/li><li>Direct field geology and structural mapping (including UAV\/LiDAR); provide structural models and rock-type controls to Geotechnical and Hydrogeology for slope design inputs and pore-pressure management.<\/li><li>Develop and evaluate resource expansion opportunities; plan and interpret RC\/diamond drilling; advance concepts efficiently from target to decision.<\/li><li>Maintain a single-source-of-truth geoscience database (e.g., acQuire or equivalent); enforce data governance, coding standards, and version control; automate dashboards and reporting (GIS\/Power BI).<\/li><li>Ensure all technical records, block models, and geological disclosures are SEC S-K 1300 compliant and aligned with international best practice standards, and contribute to QP-level documentation for Technical Reports.<\/li><li>Provide timely geological input to waste characterization, permitting, and environmental management.<\/li><li>Manage contractors and budgets (drilling, labs, consultants); track cost, quality, schedule, and HSE performance.<\/li><li>Promote a strong safety culture and regulatory compliance; lead field risk assessments, task observations, and continuous improvement.<\/li><li>Prepare technical memos, presentations, and training materials; clearly translate geologic complexity into actionable guidance for operations.<\/li><li>Other duties as assigned that advance orebody knowledge, safe production, and value generation.<\/li><\/ul><p style=\"color:#595959\">Requirements<\/p><p style=\"color:#595959\">Knowledge, Skills &amp; Experience:<\/p><ul><li>Bachelor&rsquo;s degree in Geology or Geological Engineering required; M.S. in Economic Geology preferred.<\/li><li>Minimum 8 years in open-pit mine geology for copper operations (grade control, modeling, reconciliation); 10+ years and prior team leadership preferred.<\/li><li>Deep understanding of porphyry-skarn copper systems, including hypogene\/supergene processes, oxide&ndash;transition&ndash;sulfide behavior, and geometallurgical implications for flotation.<\/li><li>Proficiency in Leapfrog Geo and geological modeling best practices; experience integrating mapping and drill data; competency with acQuire, Hexagon MinePlan\/MineSight or similar, and ArcGIS\/QGIS; familiarity with analytics\/visualization.<\/li><li>Demonstrated success in QAQC program design and execution, resource classification, and compliance reporting standards.<\/li><li>Proven leadership, team development, contractor management, and cross-functional collaboration with Operations, Planning, Metallurgy, Geotechnical, and Hydrogeology.<\/li><li>Excellent technical writing and presentation skills; ability to prioritize, manage multiple workstreams, and deliver to deadlines.<\/li><li>Valid driver&rsquo;s license; ability to work safely in pit conditions and lead by example in the field.<\/li><\/ul>","post_title":"Chief Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/chief-geologist-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Sahuarita","%location_state_id%":"AZ","%location_city_state%":"Sahuarita, AZ","%description%":"<p style=\"color:#595959;\">The Chief Geologist leads all mine-site geological activities for a high-tonnage open-pit, Cu-porphyry-skarn, processing sulfide ore by flotation. Emphasis is on short-range grade control and ore routing, geometallurgical domaining, resource growth, rigorous data collection\/QAQC, and timely geological inputs to mine planning. The role reports to the Technical Services Manager and collaborates closely with the Corporate Technical Team and Corporate Resource Manager. The position operates with minimal supervision, exercises sound professional judgment, and demonstrates visible leadership in safety, environmental stewardship, and cross-functional teamwork with Operations, Planning, Geotechnical, Hydrogeology, and Metallurgy.<\/p><p style=\"color:#595959;\">Duties &amp; Responsibilities:<\/p><ul><li>Lead and supervise the Mine Geology and Ore Control teams (geologists, technicians, samplers); ensure contemporary training, competency, and an inclusive, high-performance culture<\/li><li>Oversee daily geological mapping, sampling, and logging- capturing lithology, structure, alteration, and mineralization at appropriate scales for ore control and reconciliation.<\/li><li>Own short-range ore control: manage blasthole sampling and assay QAQC (CRMs, blanks, duplicates), blast-movement correction, and generation of clean dig polygons and grade control models; differentiate mill (sulfide) vs. blend vs. waste as required.<\/li><li>Integrate pit mapping, drilling, and survey data into the Leapfrog Geo 3-D model (with Seequent Central or equivalent) to maintain current, auditable interpretations for dispatch, short-range, and mid\/long-range plans.<\/li><li>Collaborate with Mine Engineering (Hexagon MinePlan\/MineSight) to deliver reliable geological constraints for short-, mid-, and life-of-mine plans; steward density models and dilution\/loss assumptions.<\/li><li>Lead grade reconciliation (daily\/weekly\/monthly): ore control vs. plant vs. resource model (tonnage, grade, metal, spatial); diagnose variances and adjust domaining, parameters, or practices accordingly.<\/li><li>Coordinate drill programs&mdash;infill, metallurgical, condemnation, and exploration&mdash;including design, supervision, sampling, chain-of-custody, laboratory interfaces, and full QAQC adherence.<\/li><li>Partner with Metallurgy to define geometallurgical domains controlling throughput, recovery, reagent consumption, and concentrate quality and support blending and Mine-to-Mill strategies.<\/li><li>Direct field geology and structural mapping (including UAV\/LiDAR); provide structural models and rock-type controls to Geotechnical and Hydrogeology for slope design inputs and pore-pressure management.<\/li><li>Develop and evaluate resource expansion opportunities; plan and interpret RC\/diamond drilling; advance concepts efficiently from target to decision.<\/li><li>Maintain a single-source-of-truth geoscience database (e.g., acQuire or equivalent); enforce data governance, coding standards, and version control; automate dashboards and reporting (GIS\/Power BI).<\/li><li>Ensure all technical records, block models, and geological disclosures are SEC S-K 1300 compliant and aligned with international best practice standards, and contribute to QP-level documentation for Technical Reports.<\/li><li>Provide timely geological input to waste characterization, permitting, and environmental management.<\/li><li>Manage contractors and budgets (drilling, labs, consultants); track cost, quality, schedule, and HSE performance.<\/li><li>Promote a strong safety culture and regulatory compliance; lead field risk assessments, task observations, and continuous improvement.<\/li><li>Prepare technical memos, presentations, and training materials; clearly translate geologic complexity into actionable guidance for operations.<\/li><li>Other duties as assigned that advance orebody knowledge, safe production, and value generation.<\/li><\/ul><p style=\"color:#595959;\">Requirements<\/p><p style=\"color:#595959;\">Knowledge, Skills &amp; Experience:<\/p><ul><li>Bachelor&rsquo;s degree in Geology or Geological Engineering required; M.S. in Economic Geology preferred.<\/li><li>Minimum 8 years in open-pit mine geology for copper operations (grade control, modeling, reconciliation); 10+ years and prior team leadership preferred.<\/li><li>Deep understanding of porphyry-skarn copper systems, including hypogene\/supergene processes, oxide&ndash;transition&ndash;sulfide behavior, and geometallurgical implications for flotation.<\/li><li>Proficiency in Leapfrog Geo and geological modeling best practices; experience integrating mapping and drill data; competency with acQuire, Hexagon MinePlan\/MineSight or similar, and ArcGIS\/QGIS; familiarity with analytics\/visualization.<\/li><li>Demonstrated success in QAQC program design and execution, resource classification, and compliance reporting standards.<\/li><li>Proven leadership, team development, contractor management, and cross-functional collaboration with Operations, Planning, Metallurgy, Geotechnical, and Hydrogeology.<\/li><li>Excellent technical writing and presentation skills; ability to prioritize, manage multiple workstreams, and deliver to deadlines.<\/li><li>Valid driver&rsquo;s license; ability to work safely in pit conditions and lead by example in the field.<\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/bgeyaa9jif1csxu4tiit89r6ce","%crelate_id%":"bgeyaa9jif1csxu4tiit89r6ce","%crelate_created_date%":"2026-02-12T12:09:35.1Z","%crelate_updated_date%":"2026-05-28T17:25:38.27Z","%_wpgmp_location_city%":"Sahuarita","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Sahuarita, AZUnited States","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9575818","%_wpgmp_metabox_longitude%":"-110.955646","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"190"}},"id":3286,"infowindow_disable":false}],"styles":"[{\"featureType\":\"water\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#e9e9e9\"},{\"lightness\":17}]},{\"featureType\":\"landscape\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#f5f5f5\"},{\"lightness\":20}]},{\"featureType\":\"road.highway\",\"elementType\":\"geometry.fill\",\"stylers\":[{\"color\":\"#ffffff\"},{\"lightness\":17}]},{\"featureType\":\"road.highway\",\"elementType\":\"geometry.stroke\",\"stylers\":[{\"color\":\"#ffffff\"},{\"lightness\":29},{\"weight\":0.2}]},{\"featureType\":\"road.arterial\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#ffffff\"},{\"lightness\":18}]},{\"featureType\":\"road.local\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#ffffff\"},{\"lightness\":16}]},{\"featureType\":\"poi\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#f5f5f5\"},{\"lightness\":21}]},{\"featureType\":\"poi.park\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#dedede\"},{\"lightness\":21}]},{\"elementType\":\"labels.text.stroke\",\"stylers\":[{\"visibility\":\"on\"},{\"color\":\"#ffffff\"},{\"lightness\":16}]},{\"elementType\":\"labels.text.fill\",\"stylers\":[{\"saturation\":36},{\"color\":\"#333333\"},{\"lightness\":40}]},{\"elementType\":\"labels.icon\",\"stylers\":[{\"visibility\":\"off\"}]},{\"featureType\":\"transit\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#f2f2f2\"},{\"lightness\":19}]},{\"featureType\":\"administrative\",\"elementType\":\"geometry.fill\",\"stylers\":[{\"color\":\"#fefefe\"},{\"lightness\":20}]},{\"featureType\":\"administrative\",\"elementType\":\"geometry.stroke\",\"stylers\":[{\"color\":\"#fefefe\"},{\"lightness\":17},{\"weight\":1.2}]}]","listing":{"listing_header":" ","display_search_form":true,"search_field_autosuggest":false,"display_category_filter":true,"display_sorting_filter":false,"display_radius_filter":false,"radius_dimension":"miles","radius_options":"10,50,100,200,300","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":false,"display_print_option":false,"display_grid_option":false,"filters":["place_category"],"sorting_options":{"category__asc":"A-Z Category","category__desc":"Z-A Category","title__asc":"A-Z Title","title__desc":"Z-A Title","address__asc":"A-Z Address","address__desc":"Z-A Address"},"default_sorting":{"orderby":"title","inorder":"asc"},"listing_container":".location_listing1","tabs_container":".location_listing1","hide_locations":false,"filters_position":"default","hide_map":false,"pagination":{"listing_per_page":"50"},"list_grid":"wpgmp_listing_list","listing_placeholder":"<li class=\"tsg-jb-listing-container\">\r\n  <div class=\"tsg-jb-name\">\r\n    {post_title}\r\n  <\/div>\r\n  <div class=\"tsg-jb-location\">\r\n    {marker_city}, {marker_state}\r\n  <\/div>\r\n  <div class=\"tsg-jb-link\">\r\n    <a href=\"{post_link}\" name=\"{post_title}\"><button class=\"button tsg-button-outline\">View\r\n  <\/button><\/a><\/div><a href=\"{post_link}\" name=\"{post_title}\">\r\n<\/a><\/li>","list_item_skin":{"name":"default","type":"item","sourcecode":"&lt;li class=&quot;tsg-jb-listing-container&quot;&gt;\r\n  &lt;div class=&quot;tsg-jb-name&quot;&gt;\r\n    {post_title}\r\n  &lt;\/div&gt;\r\n  &lt;div class=&quot;tsg-jb-location&quot;&gt;\r\n    {marker_city}, {marker_state}\r\n  &lt;\/div&gt;\r\n  &lt;div class=&quot;tsg-jb-link&quot;&gt;\r\n    &lt;a href=&quot;{post_link}&quot; name=&quot;{post_title}&quot;&gt;&lt;button class=&quot;button tsg-button-outline&quot;&gt;View\r\n  &lt;\/button&gt;&lt;\/a&gt;&lt;\/div&gt;&lt;a href=&quot;{post_link}&quot; name=&quot;{post_title}&quot;&gt;\r\n&lt;\/a&gt;&lt;\/li&gt;"}},"map_property":{"map_id":"1","debug_mode":false},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"custom_filters":{"filters":{"dropdown":{"city":"Cities","state":"States"}}},"filters_container":"[data-container=\"wpgmp-filters-container\"]"}}