Job Board

{"map_options":{"center_lat":"39.4748693","center_lng":"-118.7770407","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":"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 DriverYouYou want to work for a services company that is rapidly changing the way&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":"Turner Staffing Group \u2013 Haul Truck DriverYouYou want to work for a services company that is rapidly changing the way&hellip;","address":"Fallon, NV, USA","location":{"lat":"39.4748693","city":"Fallon","state":"NV","country":"United States","lng":"-118.7770407","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-4\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Haul Truck DriverYouYou want to work for a services company that is rapidly changing the way&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Responsibilities:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure cargo is properly loaded according to safety requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all safety policies, procedures and legislation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain paper or electronic logbook<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Requirements:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong work ethic<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willingness to learn<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to be flexible and to adapt<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with heavy equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred to have MSHA training<\/li>\n<\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%experience%":"","%location_country%":"United States","%location_city%":"Fallon","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Fallon, NV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Responsibilities:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure cargo is properly loaded according to safety requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all safety policies, procedures and legislation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain paper or electronic logbook<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Requirements:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong work ethic<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willingness to learn<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to be flexible and to adapt<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with heavy equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred to have MSHA training<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b5f58e5eeb68-haul-truck-driver","%breezy_id%":"b5f58e5eeb68","%breezy_friendly_id%":"b5f58e5eeb68-haul-truck-driver","%breezy_created_date%":"2026-10-02T17:37:10.039Z","%breezy_updated_date%":"2026-10-02T17:37:12.145Z","%_wpgmp_location_city%":"Fallon","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fallon, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.4748693","%_wpgmp_metabox_longitude%":"-118.7770407","%rank_math_internal_links_processed%":"1"}},"id":4117,"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-5\/\" 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":"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-driver-5\/","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 style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Responsibilities:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure cargo is properly loaded according to safety requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all safety policies, procedures and legislation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain paper or electronic logbook<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Requirements:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong work ethic<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willingness to learn<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to be flexible and to adapt<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with heavy equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred to have MSHA training<\/li>\n<\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Responsibilities:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure cargo is properly loaded according to safety requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all safety policies, procedures and legislation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain paper or electronic logbook<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Requirements:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong work ethic<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willingness to learn<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to be flexible and to adapt<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with heavy equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred to have MSHA training<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a7bc1f221d4c-haul-truck-driver","%breezy_id%":"a7bc1f221d4c","%breezy_friendly_id%":"a7bc1f221d4c-haul-truck-driver","%breezy_created_date%":"2026-10-02T17:37:19.520Z","%breezy_updated_date%":"2026-10-02T17:37:22.247Z","%_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"}},"id":4118,"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 style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Responsibilities:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure cargo is properly loaded according to safety requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all safety policies, procedures and legislation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain paper or electronic logbook<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Requirements:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong work ethic<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willingness to learn<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to be flexible and to adapt<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with heavy equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred to have MSHA training<\/li>\n<\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%experience%":"","%location_country%":"United States","%location_city%":"Lovelock","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Lovelock, NV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Responsibilities:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure cargo is properly loaded according to safety requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all safety policies, procedures and legislation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain paper or electronic logbook<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Requirements:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong work ethic<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willingness to learn<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to be flexible and to adapt<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with heavy equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred to have MSHA training<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/1d7957271024-haul-truck-driver","%breezy_id%":"1d7957271024","%breezy_friendly_id%":"1d7957271024-haul-truck-driver","%breezy_created_date%":"2026-10-01T20:13:48.098Z","%breezy_updated_date%":"2026-10-01T20:13:50.434Z","%_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"}},"id":4116,"infowindow_disable":false},{"source":"post","title":"Parts Clerk","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Parts Clerk\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Parts Clerk When a crusher, mixer, or kiln stops, the plant stops with it. This role keeps the right parts&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/parts-clerk\/\" name=\"Parts Clerk\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Parts Clerk When a crusher, mixer, or kiln stops, the plant stops with it. This role keeps the right parts&hellip;","address":"Schoharie, NY, USA","location":{"lat":"42.6659087","city":"Schoharie","state":"NY","country":"United States","lng":"-74.3095787","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/parts-clerk\/","zoom":19,"extra_fields":{"post_excerpt":"Parts Clerk When a crusher, mixer, or kiln stops, the plant stops with it. This role keeps the right parts&hellip;","post_content":"<h1>Parts Clerk<\/h1>\n<p>When a crusher, mixer, or kiln stops, the plant stops with it. This role keeps the right parts in the right place so maintenance can restore production safely and quickly. You will run the storeroom as a control point for uptime, cost, and safety\u2014not as a shelf of spare parts waiting to be counted.<\/p>\n<h2>Performance Objectives<\/h2>\n<ul>\n<li>Issue the correct part to the correct work order on the first request, so crews spend their time repairing equipment, not searching the cage.<\/li>\n<li>Hold inventory accuracy at or above the site target through disciplined receiving, putaway, cycle counts, and documented adjustments.<\/li>\n<li>Identify critical and long-lead parts before stockouts, and place replenishment so planned outages are not extended by missing components.<\/li>\n<li>Receive, inspect, and stage inbound parts the same shift they arrive, flagging damage, shortages, and wrong shipments before they enter inventory.<\/li>\n<li>Reduce obsolete, duplicate, and slow-moving stock by recommending min\/max changes and returns that free cash without raising downtime risk.<\/li>\n<li>Keep the storeroom orderly, labeled, and compliant with site safety rules, including hazardous materials handling and lockout support practices.<\/li>\n<li>Give supervisors a clear weekly picture of backorders, critical lows, and parts delaying open work orders.<\/li>\n<\/ul>\n<h2>Environment &amp; Resources<\/h2>\n<p>You will work on-site in a production storeroom supporting maintenance for heavy process equipment in cement, aggregates, or ready-mixed concrete operations. You report to the maintenance or plant leadership team and partner daily with mechanics, planners, purchasing, and vendors. You will use the site\u2019s computerized maintenance and inventory system, standard catalogs, and established purchasing channels. The role includes a defined parts budget, approved vendor list, and safety procedures\u2014not a blank check and not a paper-only cage.<\/p>\n<h2>Essential Qualifications<\/h2>\n<ul>\n<li>Proven storeroom or parts experience in manufacturing, heavy equipment, construction materials, or a comparable industrial setting.<\/li>\n<li>Hands-on use of an inventory or CMMS system to receive, issue, count, and reconcile parts against work orders.<\/li>\n<li>Ability to read part numbers, equipment manuals, and bills of material well enough to match the right component without guesswork.<\/li>\n<li>Working knowledge of min\/max, critical spares, and lead times, with a record of preventing avoidable stockouts.<\/li>\n<li>Comfort with forklifts or other powered equipment where required, and a consistent safety record in an industrial workplace.<\/li>\n<li>Clear written updates and the discipline to close transactions the same day they happen.<\/li>\n<\/ul>\n<h2>Role Selling Points<\/h2>\n<ul>\n<li>Your accuracy shows up in plant uptime, not in a distant report.<\/li>\n<li>You support essential infrastructure\u2014materials that become roads, buildings, and communities.<\/li>\n<li>The operation is investing in lower-carbon products and circular use of materials; reliable parts flow keeps those plants running.<\/li>\n<li>You will work with experienced maintenance crews on real equipment, not a generic warehouse aisle.<\/li>\n<li>Performance is visible: fewer stockouts, cleaner counts, faster issue, tighter spend.<\/li>\n<\/ul>\n<p>If you want a role where the cage you run decides whether the plant runs, apply with a short note on a stockout you prevented and how you proved the count was right.<\/p>","post_title":"Parts Clerk","post_link":"https:\/\/turnerstaffing.com\/position\/parts-clerk\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Schoharie","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Schoharie, NY","%education%":"","%department%":"TSG","%description%":"<h1>Parts Clerk<\/h1>\n<p>When a crusher, mixer, or kiln stops, the plant stops with it. This role keeps the right parts in the right place so maintenance can restore production safely and quickly. You will run the storeroom as a control point for uptime, cost, and safety\u2014not as a shelf of spare parts waiting to be counted.<\/p>\n<h2>Performance Objectives<\/h2>\n<ul>\n<li>Issue the correct part to the correct work order on the first request, so crews spend their time repairing equipment, not searching the cage.<\/li>\n<li>Hold inventory accuracy at or above the site target through disciplined receiving, putaway, cycle counts, and documented adjustments.<\/li>\n<li>Identify critical and long-lead parts before stockouts, and place replenishment so planned outages are not extended by missing components.<\/li>\n<li>Receive, inspect, and stage inbound parts the same shift they arrive, flagging damage, shortages, and wrong shipments before they enter inventory.<\/li>\n<li>Reduce obsolete, duplicate, and slow-moving stock by recommending min\/max changes and returns that free cash without raising downtime risk.<\/li>\n<li>Keep the storeroom orderly, labeled, and compliant with site safety rules, including hazardous materials handling and lockout support practices.<\/li>\n<li>Give supervisors a clear weekly picture of backorders, critical lows, and parts delaying open work orders.<\/li>\n<\/ul>\n<h2>Environment &amp; Resources<\/h2>\n<p>You will work on-site in a production storeroom supporting maintenance for heavy process equipment in cement, aggregates, or ready-mixed concrete operations. You report to the maintenance or plant leadership team and partner daily with mechanics, planners, purchasing, and vendors. You will use the site\u2019s computerized maintenance and inventory system, standard catalogs, and established purchasing channels. The role includes a defined parts budget, approved vendor list, and safety procedures\u2014not a blank check and not a paper-only cage.<\/p>\n<h2>Essential Qualifications<\/h2>\n<ul>\n<li>Proven storeroom or parts experience in manufacturing, heavy equipment, construction materials, or a comparable industrial setting.<\/li>\n<li>Hands-on use of an inventory or CMMS system to receive, issue, count, and reconcile parts against work orders.<\/li>\n<li>Ability to read part numbers, equipment manuals, and bills of material well enough to match the right component without guesswork.<\/li>\n<li>Working knowledge of min\/max, critical spares, and lead times, with a record of preventing avoidable stockouts.<\/li>\n<li>Comfort with forklifts or other powered equipment where required, and a consistent safety record in an industrial workplace.<\/li>\n<li>Clear written updates and the discipline to close transactions the same day they happen.<\/li>\n<\/ul>\n<h2>Role Selling Points<\/h2>\n<ul>\n<li>Your accuracy shows up in plant uptime, not in a distant report.<\/li>\n<li>You support essential infrastructure\u2014materials that become roads, buildings, and communities.<\/li>\n<li>The operation is investing in lower-carbon products and circular use of materials; reliable parts flow keeps those plants running.<\/li>\n<li>You will work with experienced maintenance crews on real equipment, not a generic warehouse aisle.<\/li>\n<li>Performance is visible: fewer stockouts, cleaner counts, faster issue, tighter spend.<\/li>\n<\/ul>\n<p>If you want a role where the cage you run decides whether the plant runs, apply with a short note on a stockout you prevented and how you proved the count was right.<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/012af468a445-parts-clerk","%breezy_id%":"012af468a445","%breezy_friendly_id%":"012af468a445-parts-clerk","%breezy_created_date%":"2026-09-30T22:14:19.147Z","%breezy_updated_date%":"2026-09-30T22:14:21.192Z","%_wpgmp_location_city%":"Schoharie","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Schoharie, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6659087","%_wpgmp_metabox_longitude%":"-74.3095787","%rank_math_internal_links_processed%":"1"}},"id":4114,"infowindow_disable":false},{"source":"post","title":"Parts Clerk","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Parts Clerk\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is looking for a Parts &amp; Inventory Specialist to oversee inventory management, materials receiving, and parts tracking for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/parts-clerk-2\/\" name=\"Parts Clerk\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is looking for a Parts &amp; Inventory Specialist to oversee inventory management, materials receiving, and parts tracking for&hellip;","address":"Schoharie, NY, USA","location":{"lat":"42.6659087","city":"Schoharie","state":"NY","country":"United States","lng":"-74.3095787","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/parts-clerk-2\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is looking for a Parts &amp; Inventory Specialist to oversee inventory management, materials receiving, and parts tracking for&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Our client is looking for a<strong> Parts &amp; Inventory Specialist<\/strong> to oversee inventory management, materials receiving, and parts tracking for their facility. In this role, you will keep our maintenance operations fully stocked, organized, and running without interruption.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Inventory Control:<\/strong> Maintain an accurate, organized inventory system for maintenance parts, supplies, and operational materials.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Receiving &amp; Distribution:<\/strong> Inspect, track, and distribute incoming shipments while keeping inventory management software up to date.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Parts Coordination:<\/strong> Support maintenance technicians by sourcing necessary components and coordinating fast, reliable deliveries.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Stock Optimization:<\/strong> Monitor inventory thresholds proactively to prevent shortages and identify reorder needs before delays occur.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Documentation &amp; Safety:<\/strong> Ensure accurate record-keeping, clear bin labeling, and strict compliance with company safety standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What We Are Looking For<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Hands-on experience managing inventory systems, parts sourcing, or warehouse operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong organizational skills with the ability to multitask in a fast-paced environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Effective communication skills and a team-first mindset when working alongside operational crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Sharp attention to detail and a proactive approach to safety and problem-solving.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span style=\"font-family:Arial;font-size:16px\"><span class=\"ql-cursor\">\ufeff<\/span><\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Environment &amp; Requirements<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Physical Context:<\/strong> Operates in an active industrial setting around moving machinery. Work includes exposure to outdoor weather, temperature variations (heat, cold, humidity), and elevated work areas.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Employment Screenings:<\/strong> Successful candidates must pass a post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Compliance:<\/strong> Strict adherence to site safety protocols and company regulations is required at all times.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span style=\"font-family:Arial;font-size:16px\">The salary range for the role is $22.00- $28.00 hourly.<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span style=\"font-family:Arial;font-size:16px\">This is an on-site role in Schoharie, NY.  <\/span><\/p>","post_title":"Parts Clerk","post_link":"https:\/\/turnerstaffing.com\/position\/parts-clerk-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Schoharie","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Schoharie, NY","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Our client is looking for a<strong> Parts &amp; Inventory Specialist<\/strong> to oversee inventory management, materials receiving, and parts tracking for their facility. In this role, you will keep our maintenance operations fully stocked, organized, and running without interruption.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Inventory Control:<\/strong> Maintain an accurate, organized inventory system for maintenance parts, supplies, and operational materials.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Receiving &amp; Distribution:<\/strong> Inspect, track, and distribute incoming shipments while keeping inventory management software up to date.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Parts Coordination:<\/strong> Support maintenance technicians by sourcing necessary components and coordinating fast, reliable deliveries.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Stock Optimization:<\/strong> Monitor inventory thresholds proactively to prevent shortages and identify reorder needs before delays occur.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Documentation &amp; Safety:<\/strong> Ensure accurate record-keeping, clear bin labeling, and strict compliance with company safety standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What We Are Looking For<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Hands-on experience managing inventory systems, parts sourcing, or warehouse operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong organizational skills with the ability to multitask in a fast-paced environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Effective communication skills and a team-first mindset when working alongside operational crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Sharp attention to detail and a proactive approach to safety and problem-solving.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);\"><span class=\"ql-cursor\">\ufeff<\/span><\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Environment &amp; Requirements<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Physical Context:<\/strong> Operates in an active industrial setting around moving machinery. Work includes exposure to outdoor weather, temperature variations (heat, cold, humidity), and elevated work areas.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Employment Screenings:<\/strong> Successful candidates must pass a post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Compliance:<\/strong> Strict adherence to site safety protocols and company regulations is required at all times.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);\">The salary range for the role is $22.00- $28.00 hourly.<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);\">This is an on-site role in Schoharie, NY.  <\/span><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a80ffd1f9ae7-parts-clerk","%breezy_id%":"a80ffd1f9ae7","%breezy_friendly_id%":"a80ffd1f9ae7-parts-clerk","%breezy_created_date%":"2026-09-30T22:28:32.635Z","%breezy_updated_date%":"2026-09-30T22:28:35.305Z","%_wpgmp_location_city%":"Schoharie","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Schoharie, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6659087","%_wpgmp_metabox_longitude%":"-74.3095787","%rank_math_internal_links_processed%":"1"}},"id":4115,"infowindow_disable":false},{"source":"post","title":"Production Miner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Production Miner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: &nbsp; The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/production-miner\/\" name=\"Production Miner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: &nbsp; The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group.&hellip;","address":"Ely, NV, USA","location":{"lat":"39.2533328","city":"Ely","state":"NV","country":"United States","lng":"-114.874248","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/production-miner\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description: &nbsp; The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group.&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into an equipment operator or maintenance technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Objectives and Contributions:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Engage crews and leadership to define processes that motivate working towards common goals<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Assist with MSHA regulatory task training and verify compliance to standards<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Live the values as part of a visible daily decision-making process<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Involvement in risk assessment processes at various levels of the organization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintains a high standard of housekeeping (machine and work areas)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\t<u>Culture and Communication:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Can effectively communicate in English (multi-lingual preferred)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work with crews to support proactive near miss reporting<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Leads by example (walks the talk)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\t<u>Systems:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\t<u>Travel and New Site Development: <\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintains a valid and insurable driving license<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\t<u>&nbsp;<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\t<u>Time and Interactions:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Excellent time management skills<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\t<u>Qualifications:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0-1 years\u2019 experience in mining \/ heavy industry preferred<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to obtain a working knowledge of safety systems and processes<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Appropriate attention to detail required<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong communication skills<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong morals and values<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Exemplary attendance record<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Exemplary safety and disciplinary record<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Willingness to be flexible on daily job duty requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintains a positive outspoken learning attitude<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification: <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">o&nbsp;&nbsp;<strong>Water truck, <\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">o&nbsp;&nbsp;<strong>Haulage Truck<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>OR<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">o&nbsp;&nbsp;<strong>Maintenance Work Identification, Preventive Maintenance including Operator Basic Care<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">o&nbsp;&nbsp;<strong>Fuel \/ Lube Truck<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>&nbsp;<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\t<u>Other Duties:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><u>Physical Demands:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>&nbsp;<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The physical requirements listed below are essential functions of this position and must be performed, with or without reasonable accommodation: <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Weight Requirement: Ability to meet equipment manufacturer\u2019s safety requirements, including a body weight under 330 pounds. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Mobility &amp; Posture: Ability to kneel, crouch, squat, climb stairs, and climb ladders repeatedly. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Reaching &amp; Movement: Ability to reach forward and overhead, and to perform sustained or repetitive movements of the neck, hands, wrists, and ankles\/feet. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strength &amp; Endurance: Ability to push and pull with a force of at least 100 pounds. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">o&nbsp;&nbsp;Ability to lift, carry, and set down objects weighing up to 100 pounds. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">o&nbsp;&nbsp;Ability to lift and carry objects overhead weighing up to 45 pounds. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">o&nbsp;&nbsp;Ability to lift and move items from floor level to waist, shoulder, and overhead levels. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">o&nbsp;&nbsp;Ability to carry weights over distances of at least 20 feet. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Repetition &amp; Duration: Ability to perform the above motions multiple times in succession and sustain activity for extended periods. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Production Miner","post_link":"https:\/\/turnerstaffing.com\/position\/production-miner\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into an equipment operator or maintenance technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Objectives and Contributions:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Engage crews and leadership to define processes that motivate working towards common goals<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Assist with MSHA regulatory task training and verify compliance to standards<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Live the values as part of a visible daily decision-making process<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Involvement in risk assessment processes at various levels of the organization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintains a high standard of housekeeping (machine and work areas)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\t<u>Culture and Communication:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Can effectively communicate in English (multi-lingual preferred)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work with crews to support proactive near miss reporting<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Leads by example (walks the talk)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\t<u>Systems:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\t<u>Travel and New Site Development: <\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintains a valid and insurable driving license<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\t<u>&nbsp;<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\t<u>Time and Interactions:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Excellent time management skills<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\t<u>Qualifications:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;0-1 years\u2019 experience in mining \/ heavy industry preferred<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to obtain a working knowledge of safety systems and processes<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Appropriate attention to detail required<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong communication skills<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong morals and values<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Exemplary attendance record<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Exemplary safety and disciplinary record<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Willingness to be flexible on daily job duty requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintains a positive outspoken learning attitude<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification: <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">o&nbsp;&nbsp;<strong>Water truck, <\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">o&nbsp;&nbsp;<strong>Haulage Truck<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>OR<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">o&nbsp;&nbsp;<strong>Maintenance Work Identification, Preventive Maintenance including Operator Basic Care<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">o&nbsp;&nbsp;<strong>Fuel \/ Lube Truck<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>&nbsp;<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\t<u>Other Duties:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><u>Physical Demands:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>&nbsp;<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The physical requirements listed below are essential functions of this position and must be performed, with or without reasonable accommodation: <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Weight Requirement: Ability to meet equipment manufacturer\u2019s safety requirements, including a body weight under 330 pounds. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Mobility &amp; Posture: Ability to kneel, crouch, squat, climb stairs, and climb ladders repeatedly. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Reaching &amp; Movement: Ability to reach forward and overhead, and to perform sustained or repetitive movements of the neck, hands, wrists, and ankles\/feet. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strength &amp; Endurance: Ability to push and pull with a force of at least 100 pounds. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">o&nbsp;&nbsp;Ability to lift, carry, and set down objects weighing up to 100 pounds. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">o&nbsp;&nbsp;Ability to lift and carry objects overhead weighing up to 45 pounds. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">o&nbsp;&nbsp;Ability to lift and move items from floor level to waist, shoulder, and overhead levels. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">o&nbsp;&nbsp;Ability to carry weights over distances of at least 20 feet. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Repetition &amp; Duration: Ability to perform the above motions multiple times in succession and sustain activity for extended periods. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a68734de8c68-production-miner","%breezy_id%":"a68734de8c68","%breezy_friendly_id%":"a68734de8c68-production-miner","%breezy_created_date%":"2026-09-28T19:12:09.604Z","%breezy_updated_date%":"2026-09-28T19:12:11.754Z","%_wpgmp_location_city%":"Ely","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ely, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2533328","%_wpgmp_metabox_longitude%":"-114.874248","%rank_math_internal_links_processed%":"1"}},"id":4049,"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    Join our dynamic team at one of Alaska&#8217;s premier gold mines as a Geotechnician! This is a unique opportunity for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geotechnician\/\" name=\"Geotechnician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Join our dynamic team at one of Alaska&#8217;s premier gold mines as a Geotechnician! This is a unique opportunity for&hellip;","address":", AK, USA","location":{"lat":"63.588753","state":"AK","country":"United States","lng":"-154.4930619","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geotechnician\/","zoom":19,"extra_fields":{"post_excerpt":"Join our dynamic team at one of Alaska&#8217;s premier gold mines as a Geotechnician! This is a unique opportunity for&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Join our dynamic team at one of Alaska's premier gold mines as a Geotechnician! This is a unique opportunity for an individual with a passion for geology and hands-on fieldwork. As an Geotechnician, you will play a crucial role in the exploration and development of a gold mine near Fairbanks. This position operates on a 2-week on, 2-week off schedule, with 12-hour shifts, providing an exciting work-life balance for those ready to embrace the challenges and rewards of the mining industry.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities:<\/p><ol style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Rock Core Management: Transporting, cutting, prepping, and logging rock core samples with precision and attention to detail.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Field Operations: Conduct field surveys, collect geological data, and contribute to the overall geological assessment of the mine site.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety Compliance: Adhere to strict safety protocols and procedures to ensure a secure working environment for yourself and your team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equipment Operation: Operate various geotechnical tools and machinery with a focus on safety and efficiency.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Data Recording and Analysis: Maintain accurate records of geological data and collaborate with the geology team to analyze findings.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Other duties as assigned.<\/li>\n<\/ol><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications:<\/p><ol style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience: Prior experience in a mining or exploration environment is preferred, but not mandatory.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">License: Valid driver's license and a clean driving record are required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical Ability: Ability to lift 50 lbs repeatedly throughout the shift and work in challenging outdoor conditions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communication Skills: Strong verbal and written communication skills for effective collaboration within the team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Adaptability: Willingness to work in a dynamic and changing environment, adapting to the needs of the project.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must be authorized to work in the US without work visa sponsorship<\/li>\n<\/ol>","post_title":"Geotechnician","post_link":"https:\/\/turnerstaffing.com\/position\/geotechnician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%experience%":"","%location_country%":"United States","%location_city%":"","%location_state_id%":"AK","%location_state_name%":"Alaska","%location_city_state%":"United States","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Join our dynamic team at one of Alaska's premier gold mines as a Geotechnician! This is a unique opportunity for an individual with a passion for geology and hands-on fieldwork. As an Geotechnician, you will play a crucial role in the exploration and development of a gold mine near Fairbanks. This position operates on a 2-week on, 2-week off schedule, with 12-hour shifts, providing an exciting work-life balance for those ready to embrace the challenges and rewards of the mining industry.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities:<\/p><ol style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Rock Core Management: Transporting, cutting, prepping, and logging rock core samples with precision and attention to detail.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Field Operations: Conduct field surveys, collect geological data, and contribute to the overall geological assessment of the mine site.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety Compliance: Adhere to strict safety protocols and procedures to ensure a secure working environment for yourself and your team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equipment Operation: Operate various geotechnical tools and machinery with a focus on safety and efficiency.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Data Recording and Analysis: Maintain accurate records of geological data and collaborate with the geology team to analyze findings.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Other duties as assigned.<\/li>\n<\/ol><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications:<\/p><ol style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience: Prior experience in a mining or exploration environment is preferred, but not mandatory.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">License: Valid driver's license and a clean driving record are required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical Ability: Ability to lift 50 lbs repeatedly throughout the shift and work in challenging outdoor conditions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communication Skills: Strong verbal and written communication skills for effective collaboration within the team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Adaptability: Willingness to work in a dynamic and changing environment, adapting to the needs of the project.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must be authorized to work in the US without work visa sponsorship<\/li>\n<\/ol>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/bcd5a1efe4b5-geotechnician","%breezy_id%":"bcd5a1efe4b5","%breezy_friendly_id%":"bcd5a1efe4b5-geotechnician","%breezy_created_date%":"2026-09-28T19:51:43.190Z","%breezy_updated_date%":"2026-09-28T19:51:45.299Z","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":", AK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"63.588753","%_wpgmp_metabox_longitude%":"-154.4930619","%rank_math_internal_links_processed%":"1"}},"id":4050,"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-3\/\" 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-3\/","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-3\/","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-09-28T20:20:41.578Z","%_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":4048,"infowindow_disable":false},{"source":"post","title":"Mobile Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mobile Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You&#8217;ll Be Doing Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime. Perform preventive maintenance on loaders, haul&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mobile-mechanic-3\/\" name=\"Mobile Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You&#8217;ll Be Doing Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime. Perform preventive maintenance on loaders, haul&hellip;","address":"Geneva, NY, USA","location":{"lat":"42.8679836","city":"Geneva","state":"NY","country":"United States","lng":"-76.985557","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mobile-mechanic-3\/","zoom":19,"extra_fields":{"post_excerpt":"What You&#8217;ll Be Doing Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime. Perform preventive maintenance on loaders, haul&hellip;","post_content":"<p>What You'll Be Doing<\/p>\n<ul><li>Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime.<\/li><li>Perform preventive maintenance on loaders, haul trucks, excavators, and other heavy equipment.<\/li><li>Inspect equipment and identify mechanical, hydraulic, electrical, and safety concerns.<\/li><li>Maintain accurate service records and communicate repair needs effectively.<\/li><li>Support safe, reliable plant operations through quality workmanship and teamwork.<\/li><\/ul>\n<p>What Are We Looking For<\/p>\n<ul><li>Demonstrated capability to diagnose and repair heavy mobile equipment systems.<\/li><li>Strong mechanical aptitude with the ability to troubleshoot hydraulic, electrical, and diesel-powered equipment.<\/li><li>Commitment to workplace safety and adherence to established procedures.<\/li><li>Ability to prioritize tasks, solve problems, and work effectively with minimal supervision.<\/li><li>Effective communication skills and a collaborative, team-oriented mindset.<\/li><li>&nbsp;<\/li><\/ul>\n<p>Conditions of Employment<\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing.<\/li><li>&nbsp;<\/li><\/ul>\n<p>Work Environment<\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><li>&nbsp;<\/li><\/ul>\n<p>What We Offer<\/p>\n<ul><li>$28.00 to $35.00 per hour<\/li><li>401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li><li>Highly competitive benefits programs, including:<\/li><li>Medical, Dental, and Vision along with Prescription Drug Benefits<\/li><li>Health Saving Savings Account (HSA), Health Reimbursement Account (HRA) and Flexible Spending Account (FSA)<\/li><li>AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li><li>Paid Bonding Leave, 10 days of Paid Vacation, 40 hours of Paid Sick Leave and 10 Paid Holidays<\/li><\/ul>\n<p>Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p>\n<p>equipment Mechanic<\/p>\n<p><br>\n\n<\/p>","post_title":"Mobile Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mobile-mechanic-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Geneva","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Geneva, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p>What You'll Be Doing<\/p>\n<ul><li>Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime.<\/li><li>Perform preventive maintenance on loaders, haul trucks, excavators, and other heavy equipment.<\/li><li>Inspect equipment and identify mechanical, hydraulic, electrical, and safety concerns.<\/li><li>Maintain accurate service records and communicate repair needs effectively.<\/li><li>Support safe, reliable plant operations through quality workmanship and teamwork.<\/li><\/ul>\n<p>What Are We Looking For<\/p>\n<ul><li>Demonstrated capability to diagnose and repair heavy mobile equipment systems.<\/li><li>Strong mechanical aptitude with the ability to troubleshoot hydraulic, electrical, and diesel-powered equipment.<\/li><li>Commitment to workplace safety and adherence to established procedures.<\/li><li>Ability to prioritize tasks, solve problems, and work effectively with minimal supervision.<\/li><li>Effective communication skills and a collaborative, team-oriented mindset.<\/li><li>&nbsp;<\/li><\/ul>\n<p>Conditions of Employment<\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing.<\/li><li>&nbsp;<\/li><\/ul>\n<p>Work Environment<\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><li>&nbsp;<\/li><\/ul>\n<p>What We Offer<\/p>\n<ul><li>$28.00 to $35.00 per hour<\/li><li>401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li><li>Highly competitive benefits programs, including:<\/li><li>Medical, Dental, and Vision along with Prescription Drug Benefits<\/li><li>Health Saving Savings Account (HSA), Health Reimbursement Account (HRA) and Flexible Spending Account (FSA)<\/li><li>AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li><li>Paid Bonding Leave, 10 days of Paid Vacation, 40 hours of Paid Sick Leave and 10 Paid Holidays<\/li><\/ul>\n<p>Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p>\n<p>equipment Mechanic<\/p>\n<p><br>\n\n<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/9eebe530d1b9-mobile-mechanic","%breezy_id%":"9eebe530d1b9","%breezy_friendly_id%":"9eebe530d1b9-mobile-mechanic","%breezy_created_date%":"2026-09-25T01:19:12.729Z","%breezy_updated_date%":"2026-09-25T01:20:08.969Z","%_wpgmp_location_city%":"Geneva","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Geneva, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.8679836","%_wpgmp_metabox_longitude%":"-76.985557","%rank_math_internal_links_processed%":"1"}},"id":4043,"infowindow_disable":false},{"source":"post","title":"Mobile Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mobile Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You&#8217;ll Be Doing Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime. Perform preventive maintenance on loaders, haul&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mobile-mechanic-4\/\" name=\"Mobile Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You&#8217;ll Be Doing Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime. Perform preventive maintenance on loaders, haul&hellip;","address":"Geneva, NY, USA","location":{"lat":"42.8679836","city":"Geneva","state":"NY","country":"United States","lng":"-76.985557","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mobile-mechanic-4\/","zoom":19,"extra_fields":{"post_excerpt":"What You&#8217;ll Be Doing Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime. Perform preventive maintenance on loaders, haul&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What You'll Be Doing<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform preventive maintenance on loaders, haul trucks, excavators, and other heavy equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Inspect equipment and identify mechanical, hydraulic, electrical, and safety concerns.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain accurate service records and communicate repair needs effectively.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support safe, reliable plant operations through quality workmanship and teamwork.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What Are We Looking For<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated capability to diagnose and repair heavy mobile equipment systems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong mechanical aptitude with the ability to troubleshoot hydraulic, electrical, and diesel-powered equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Commitment to workplace safety and adherence to established procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to prioritize tasks, solve problems, and work effectively with minimal supervision.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Effective communication skills and a collaborative, team-oriented mindset.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conditions of Employment<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Some positions require FMCSA regulated ongoing drug and alcohol testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Environment<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What We Offer<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">$28.00 to $35.00 per hour<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Highly competitive benefits programs, including:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Medical, Dental, and Vision along with Prescription Drug Benefits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Health Saving Savings Account (HSA), Health Reimbursement Account (HRA) and Flexible Spending Account (FSA)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Paid Bonding Leave, 10 days of Paid Vacation, 40 hours of Paid Sick Leave and 10 Paid Holidays<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">quipment Mechanic<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Mobile Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mobile-mechanic-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Geneva","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Geneva, NY","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What You'll Be Doing<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Diagnose, troubleshoot, and repair mobile equipment to maximize operational uptime.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform preventive maintenance on loaders, haul trucks, excavators, and other heavy equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Inspect equipment and identify mechanical, hydraulic, electrical, and safety concerns.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain accurate service records and communicate repair needs effectively.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support safe, reliable plant operations through quality workmanship and teamwork.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What Are We Looking For<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated capability to diagnose and repair heavy mobile equipment systems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong mechanical aptitude with the ability to troubleshoot hydraulic, electrical, and diesel-powered equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Commitment to workplace safety and adherence to established procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to prioritize tasks, solve problems, and work effectively with minimal supervision.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Effective communication skills and a collaborative, team-oriented mindset.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conditions of Employment<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Some positions require FMCSA regulated ongoing drug and alcohol testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Environment<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What We Offer<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">$28.00 to $35.00 per hour<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Highly competitive benefits programs, including:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Medical, Dental, and Vision along with Prescription Drug Benefits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Health Saving Savings Account (HSA), Health Reimbursement Account (HRA) and Flexible Spending Account (FSA)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Paid Bonding Leave, 10 days of Paid Vacation, 40 hours of Paid Sick Leave and 10 Paid Holidays<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">quipment Mechanic<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b0f01b9d4e6f-mobile-mechanic","%breezy_id%":"b0f01b9d4e6f","%breezy_friendly_id%":"b0f01b9d4e6f-mobile-mechanic","%breezy_created_date%":"2026-09-25T01:54:21.035Z","%breezy_updated_date%":"2026-09-25T01:54:23.437Z","%_wpgmp_location_city%":"Geneva","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Geneva, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.8679836","%_wpgmp_metabox_longitude%":"-76.985557","%rank_math_internal_links_processed%":"1"}},"id":4044,"infowindow_disable":false},{"source":"post","title":"Diagnostic Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Diagnostic Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Diagnostic Electrician Freeport-McMoRan operates world-class copper assets that power global electrification. As a Diagnostic Electrician you will keep high-value industrial&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/diagnostic-electrician\/\" name=\"Diagnostic Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Diagnostic Electrician Freeport-McMoRan operates world-class copper assets that power global electrification. As a Diagnostic Electrician you will keep high-value industrial&hellip;","address":"Leadville, CO, USA","location":{"lat":"39.248728","city":"Leadville","state":"CO","country":"United States","lng":"-106.2918815","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/diagnostic-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"Diagnostic Electrician Freeport-McMoRan operates world-class copper assets that power global electrification. As a Diagnostic Electrician you will keep high-value industrial&hellip;","post_content":"<h1 style=\"line-height:1.5;margin:0px\">Diagnostic Electrician<\/h1><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Freeport-McMoRan operates world-class copper assets that power global electrification. As a Diagnostic Electrician you will keep high-value industrial and instrumentation running by rapidly isolating electrical faults, protecting people and production at sites. Your work directly supports our core values of Safety, Respect, Integrity, Excellence and Commitment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Will Do<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Removal, repair and installation of electrical components, electrical systems, analysis and diagnosis, advanced troubleshooting and systems\/process optimization; may mentor or train other electrical workers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safe completion of routine and non-routine repairs and construction<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform preventative maintenance including installation, repair and troubleshooting of industrical electrical and\/or instrumentation equipment (i.e. substations, power distribution systems, switchgear motors, motor controls, systems and components, process controls, instrumentation and pneumatic equipment)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have strong knowledge in the maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, management control systems, calibration of field transmitters\/transducers and weigh scales, and low and medium voltage equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to perform installations and renovations compliant with regulatory agency standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow Standard Operating Procedues (SOP) and work area instructions, participate in safety and environmental activities, and use plant and equipment correctly at all times<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Bring To Freeport<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Completion of an approved Certified Electronics, Electrical and\/or Instrumentation Program,\u202f<strong>OR&nbsp;<\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Minimum of four (4) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance,\u202f<strong>OR&nbsp;<\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Associate's degree or Trade School Certification in a related field\u202f<strong>and\u202f<\/strong>two (2) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience in troubleshooting, maintenance and repair of electrical circuits and connected equipment; this includes the ability to read, understand and apply information from technical manuals, prints, and schematics for trouble shooting and repair&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Effective written and verbal communication skills to satisfy training, safety, and electronic message transmission policies of the company&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have minimum personal tools as described by the department tool list or be able to obtain them within 90 days of hire date&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have completed academic and practical competencies required (this includes Line of Progression requirements for internal employees where LOP Exists) and have experience demonstrating the required aptitude. The selected candidate shall demonstrate the ability to apply knowledge and skills while also passing a written assessment where required. This exam is based on skills\/abilities and\/or academic knowledge; as well as safety.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Preferred Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High School diploma or GED&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with VFDs, PLC, HMI, and\/or SCADA Control Systems&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience working with low and medium voltages&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with AC and\/or DC controls&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with instrumentation devices&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with diagnostic electrical test equipment&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with HVAC equipment&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Diagnostic Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/diagnostic-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Leadville","%location_state_id%":"CO","%location_state_name%":"Colorado","%location_city_state%":"Leadville, CO","%education%":"","%department%":"TSG","%description%":"<h1 style=\"line-height:1.5;margin:0px;\">Diagnostic Electrician<\/h1><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Freeport-McMoRan operates world-class copper assets that power global electrification. As a Diagnostic Electrician you will keep high-value industrial and instrumentation running by rapidly isolating electrical faults, protecting people and production at sites. Your work directly supports our core values of Safety, Respect, Integrity, Excellence and Commitment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Will Do<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Removal, repair and installation of electrical components, electrical systems, analysis and diagnosis, advanced troubleshooting and systems\/process optimization; may mentor or train other electrical workers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safe completion of routine and non-routine repairs and construction<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform preventative maintenance including installation, repair and troubleshooting of industrical electrical and\/or instrumentation equipment (i.e. substations, power distribution systems, switchgear motors, motor controls, systems and components, process controls, instrumentation and pneumatic equipment)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have strong knowledge in the maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, management control systems, calibration of field transmitters\/transducers and weigh scales, and low and medium voltage equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to perform installations and renovations compliant with regulatory agency standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow Standard Operating Procedues (SOP) and work area instructions, participate in safety and environmental activities, and use plant and equipment correctly at all times<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Bring To Freeport<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Completion of an approved Certified Electronics, Electrical and\/or Instrumentation Program,\u202f<strong>OR&nbsp;<\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Minimum of four (4) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance,\u202f<strong>OR&nbsp;<\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Associate's degree or Trade School Certification in a related field\u202f<strong>and\u202f<\/strong>two (2) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience in troubleshooting, maintenance and repair of electrical circuits and connected equipment; this includes the ability to read, understand and apply information from technical manuals, prints, and schematics for trouble shooting and repair&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Effective written and verbal communication skills to satisfy training, safety, and electronic message transmission policies of the company&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have minimum personal tools as described by the department tool list or be able to obtain them within 90 days of hire date&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have completed academic and practical competencies required (this includes Line of Progression requirements for internal employees where LOP Exists) and have experience demonstrating the required aptitude. The selected candidate shall demonstrate the ability to apply knowledge and skills while also passing a written assessment where required. This exam is based on skills\/abilities and\/or academic knowledge; as well as safety.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Preferred Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High School diploma or GED&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with VFDs, PLC, HMI, and\/or SCADA Control Systems&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience working with low and medium voltages&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with AC and\/or DC controls&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with instrumentation devices&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with diagnostic electrical test equipment&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with HVAC equipment&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ee9d8a13784c-diagnostic-electrician","%breezy_id%":"ee9d8a13784c","%breezy_friendly_id%":"ee9d8a13784c-diagnostic-electrician","%breezy_created_date%":"2026-09-23T03:22:37.700Z","%breezy_updated_date%":"2026-09-23T03:22:40.023Z","%_wpgmp_location_city%":"Leadville","%_wpgmp_location_state%":"CO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Leadville, CO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.248728","%_wpgmp_metabox_longitude%":"-106.2918815","%rank_math_internal_links_processed%":"1"}},"id":4040,"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    Overview Turner Staffing Group is partnered with a quarry in Hinkley, CA that is looking for an Excavator Operator. This&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-17\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Overview Turner Staffing Group is partnered with a quarry in Hinkley, CA that is looking for an Excavator Operator. This&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\/excavator-operator-17\/","zoom":19,"extra_fields":{"post_excerpt":"Overview Turner Staffing Group is partnered with a quarry in Hinkley, CA that is looking for an Excavator Operator. This&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Overview<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is partnered with a quarry in Hinkley, CA that is looking for an Excavator Operator. This is a key production role responsible for efficiently loading haul trucks and supporting material movement across the site.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">If you're 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate an excavator to load haul trucks with overburden, ore, or aggregate material<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain consistent production rates while minimizing spillage and rework<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure proper digging and loading techniques to maximize efficiency and equipment longevity<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct pre-shift and post-shift inspections of equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify and report mechanical issues or unsafe conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all site safety policies and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate effectively with haul truck drivers, dispatch, and supervisors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain clean work areas and assist with general production support as needed<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proven experience operating an excavator in a mining, quarry, or heavy civil environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of loading patterns, material handling, and production goals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver's license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA certification (preferred; may be required prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in a physically demanding outdoor environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong situational awareness and commitment to safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reliable transportation and consistent attendance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span style=\"font-family:Arial;font-size:16px\"><span class=\"ql-cursor\">\ufeff<\/span><\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What We're Looking For<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operators who can load safely, efficiently, and consistently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Individuals who understand production targets and take ownership of performance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Team players who communicate clearly and work well in a fast-paced environment<\/li>\n<\/ul><h1 style=\"line-height:1.5;margin:0px\"><br><\/h1>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-17\/","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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Overview<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is partnered with a quarry in Hinkley, CA that is looking for an Excavator Operator. This is a key production role responsible for efficiently loading haul trucks and supporting material movement across the site.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">If you're 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate an excavator to load haul trucks with overburden, ore, or aggregate material<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain consistent production rates while minimizing spillage and rework<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure proper digging and loading techniques to maximize efficiency and equipment longevity<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct pre-shift and post-shift inspections of equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify and report mechanical issues or unsafe conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all site safety policies and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate effectively with haul truck drivers, dispatch, and supervisors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain clean work areas and assist with general production support as needed<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proven experience operating an excavator in a mining, quarry, or heavy civil environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of loading patterns, material handling, and production goals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver's license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA certification (preferred; may be required prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in a physically demanding outdoor environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong situational awareness and commitment to safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reliable transportation and consistent attendance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);\"><span class=\"ql-cursor\">\ufeff<\/span><\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What We're Looking For<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operators who can load safely, efficiently, and consistently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Individuals who understand production targets and take ownership of performance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Team players who communicate clearly and work well in a fast-paced environment<\/li>\n<\/ul><h1 style=\"line-height:1.5;margin:0px;\"><br><\/h1>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/093c5f7024a8-excavator-operator","%breezy_id%":"093c5f7024a8","%breezy_friendly_id%":"093c5f7024a8-excavator-operator","%breezy_created_date%":"2026-09-22T19:21:29.533Z","%breezy_updated_date%":"2026-09-22T19:21:31.726Z","%_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":4038,"infowindow_disable":false},{"source":"post","title":"Production Miner &#8211; Haul Truck","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Production Miner &#8211; Haul Truck\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Production Miner&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/production-miner-haul-truck\/\" name=\"Production Miner &#8211; Haul Truck\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Production Miner&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;","address":"Crane, TX, USA","location":{"lat":"31.3973624","city":"Crane","state":"TX","country":"United States","lng":"-102.3501419","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/production-miner-haul-truck\/","zoom":19,"extra_fields":{"post_excerpt":"Production Miner&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Production Miner&nbsp;<\/strong>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Reports to:<\/strong> Foreman \u2013 Turner Mining Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Objectives and Contributions:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp;The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Engage crews and leadership to define processes that motivate working towards common goals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with MSHA regulatory task training and verify compliance to standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Live the values as part of a visible daily decision-making process<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with training proficiency audits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Involvement in risk assessment processes at various levels of the organization<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being&nbsp;accountable for conditions and behaviors)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintains a high standard of housekeeping (machine and work areas)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><u>Culture and Communication:<\/u><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Can effectively communicate in English (multi-lingual preferred)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in site and project leaders to identify areas of improvement<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work with crews to support proactive near miss reporting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Leads by example (walks the talk)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><u>Systems:<\/u><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Accurately documents 5000-23 and training checklist requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Other regulatory &amp; internal \/ external forms as required<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><u>Travel and New Site Development:<\/u><\/p><ul style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintains a valid and insurable driving license<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><u>Time and Interactions:<\/u><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Excellent time management skills<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><u>Qualifications:<\/u><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Production Miner will be subject to a probationary period of six months from the date of hire<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Working knowledge of safety systems and processes<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Appropriate attention to detail required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong communication skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong morals and values<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Exemplary attendance record<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Exemplary safety and disciplinary record<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willingness to be flexible on daily job duty requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintains a positive outspoken learning attitude<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Production Miner will be competent and highly proficient on each piece of the following equipment:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Water truck,<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Haulage Truck<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><u>Other Duties:<\/u><\/p><ul style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><u>Physical Demands:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The physical requirements listed below are essential functions of this position and must be performed, with or without reasonable accommodation:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Weight Requirement: Ability to meet equipment manufacturer\u2019s safety requirements, including a body weight under 330 pounds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Mobility &amp; Posture: Ability to kneel, crouch, squat, climb stairs, and climb ladders repeatedly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reaching &amp; Movement: Ability to reach forward and overhead, and to perform sustained or repetitive movements of the neck, hands, wrists, and ankles\/feet.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strength &amp; Endurance: Ability to push and pull with a force of at least 55 pounds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Ability to lift, carry, and set down objects weighing up to 85 pounds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Ability to lift and carry objects overhead weighing up to 25 pounds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Ability to lift and move items from floor level to waist, shoulder, and overhead levels.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Ability to carry weights over distances of at least 20 feet.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Repetition &amp; Duration: Ability to perform the above motions multiple times in succession and sustain activity for extended periods.<\/li>\n<\/ul>","post_title":"Production Miner &#8211; Haul Truck","post_link":"https:\/\/turnerstaffing.com\/position\/production-miner-haul-truck\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Crane","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crane, TX","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Production Miner&nbsp;<\/strong>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Reports to:<\/strong> Foreman \u2013 Turner Mining Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Objectives and Contributions:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp;The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Engage crews and leadership to define processes that motivate working towards common goals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with MSHA regulatory task training and verify compliance to standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Live the values as part of a visible daily decision-making process<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with training proficiency audits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Involvement in risk assessment processes at various levels of the organization<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being&nbsp;accountable for conditions and behaviors)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintains a high standard of housekeeping (machine and work areas)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><u>Culture and Communication:<\/u><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Can effectively communicate in English (multi-lingual preferred)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in site and project leaders to identify areas of improvement<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work with crews to support proactive near miss reporting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Leads by example (walks the talk)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><u>Systems:<\/u><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Accurately documents 5000-23 and training checklist requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Other regulatory &amp; internal \/ external forms as required<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><u>Travel and New Site Development:<\/u><\/p><ul style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintains a valid and insurable driving license<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><u>Time and Interactions:<\/u><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Excellent time management skills<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><u>Qualifications:<\/u><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Production Miner will be subject to a probationary period of six months from the date of hire<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Working knowledge of safety systems and processes<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Appropriate attention to detail required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong communication skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong morals and values<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Exemplary attendance record<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Exemplary safety and disciplinary record<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willingness to be flexible on daily job duty requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintains a positive outspoken learning attitude<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Production Miner will be competent and highly proficient on each piece of the following equipment:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Water truck,<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Haulage Truck<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><u>Other Duties:<\/u><\/p><ul style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><u>Physical Demands:<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The physical requirements listed below are essential functions of this position and must be performed, with or without reasonable accommodation:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Weight Requirement: Ability to meet equipment manufacturer\u2019s safety requirements, including a body weight under 330 pounds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Mobility &amp; Posture: Ability to kneel, crouch, squat, climb stairs, and climb ladders repeatedly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reaching &amp; Movement: Ability to reach forward and overhead, and to perform sustained or repetitive movements of the neck, hands, wrists, and ankles\/feet.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strength &amp; Endurance: Ability to push and pull with a force of at least 55 pounds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Ability to lift, carry, and set down objects weighing up to 85 pounds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Ability to lift and carry objects overhead weighing up to 25 pounds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Ability to lift and move items from floor level to waist, shoulder, and overhead levels.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Ability to carry weights over distances of at least 20 feet.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Repetition &amp; Duration: Ability to perform the above motions multiple times in succession and sustain activity for extended periods.<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/1a4e1f89c5d9-production-miner-haul-truck","%breezy_id%":"1a4e1f89c5d9","%breezy_friendly_id%":"1a4e1f89c5d9-production-miner-haul-truck","%breezy_created_date%":"2026-09-22T20:15:26.798Z","%breezy_updated_date%":"2026-09-22T20:15:28.688Z","%_wpgmp_location_city%":"Crane","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crane, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.3973624","%_wpgmp_metabox_longitude%":"-102.3501419","%rank_math_internal_links_processed%":"1"}},"id":4039,"infowindow_disable":false},{"source":"post","title":"Operations Superintendent &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Operations Superintendent &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are currently seeking an experienced Operations Superintendent to lead field operations across mining and heavy civil projects. This is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/operations-superintendent-traveling\/\" name=\"Operations Superintendent &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are currently seeking an experienced Operations Superintendent to lead field operations across mining and heavy civil projects. This is&hellip;","address":", TX, USA","location":{"lat":"31.9685988","state":"TX","country":"United States","lng":"-99.9018131","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/operations-superintendent-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"We are currently seeking an experienced Operations Superintendent to lead field operations across mining and heavy civil projects. This is&hellip;","post_content":"<p>We are currently seeking an experienced Operations Superintendent to lead field operations across mining and heavy civil projects. This is a hands-on leadership role for an experienced field professional who can manage crews, coordinate equipment and production, solve operational problems in real time, and step into equipment when necessary to keep the project moving.<\/p>\n<p>This position requires significant travel to project locations. Housing will be provided while assigned to each project.<\/p>\n<p><\/p>\n<p><strong>Position Summary<\/strong><\/p>\n<p>The Operations Superintendent is responsible for the safe, efficient, and productive execution of field operations across mining and heavy civil projects. This individual will oversee crews, equipment, schedules, and day-to-day production while serving as a key field leader between project management and site personnel.<\/p>\n<p>The ideal candidate has a strong combination of mining and heavy civil experience, understands large-scale earthmoving operations, and is comfortable working directly alongside crews in the field. This is not strictly an office-based management position; the Superintendent must be willing and able to troubleshoot field issues, make operational decisions, and operate heavy equipment when needed.<\/p>\n<p><\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Field Operations &amp; Production<\/strong><\/p>\n<ul><li>Lead day-to-day field operations across mining and heavy civil projects<\/li><li>Coordinate manpower, equipment, and resources to meet production and schedule requirements<\/li><li>Develop and execute daily and weekly work plans based on project priorities<\/li><li>Monitor production progress and adjust operations as field conditions change<\/li><li>Identify bottlenecks, equipment limitations, and operational challenges and implement practical field solutions<\/li><li>Maintain a strong field presence and ensure work is progressing safely and efficiently<\/li><li>Coordinate earthmoving, excavation, grading, haulage, site development, and related field activities<\/li><\/ul>\n<p><strong>Crew Leadership<\/strong><\/p>\n<ul><li>Supervise foremen, equipment operators, laborers, and other field personnel<\/li><li>Provide clear direction regarding daily production expectations, work areas, and priorities<\/li><li>Lead pre-shift meetings, toolbox talks, and daily crew assignments<\/li><li>Coach and mentor field personnel to improve safety, productivity, and equipment utilization<\/li><li>Hold crews accountable for production, safety, workmanship, and company standards<\/li><li>Assist with staffing decisions and identify additional manpower or equipment needs<\/li><\/ul>\n<p><strong>Equipment &amp; Hands-On Support<\/strong><\/p>\n<ul><li>Coordinate utilization of heavy equipment including haul trucks, excavators, dozers, loaders, graders, and similar machinery<\/li><li>Ensure equipment is being operated safely and effectively<\/li><li>Recognize mechanical or operational issues and coordinate repairs or maintenance as needed<\/li><li>Assist operators with troubleshooting production or equipment-related challenges<\/li><li>Operate heavy equipment when necessary to support production, cover manpower gaps, or resolve field issues<\/li><li>Work closely with maintenance teams to minimize equipment downtime<\/li><\/ul>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul><li>Promote and enforce a strong safety culture across all field operations<\/li><li>Ensure compliance with MSHA requirements, company policies, and site-specific safety procedures<\/li><li>Conduct field inspections and identify hazards, unsafe conditions, or operational risks<\/li><li>Participate in incident investigations and corrective-action planning when required<\/li><li>Ensure crews consistently follow PPE, equipment, and safe-work requirements<\/li><\/ul>\n<p><strong>Project Coordination<\/strong><\/p>\n<ul><li>Communicate regularly with project managers and senior operations leadership regarding production, manpower, equipment, and project challenges<\/li><li>Coordinate with subcontractors, vendors, maintenance personnel, and client representatives as required<\/li><li>Provide accurate daily production updates, operational reports, and field documentation<\/li><li>Assist with short-term planning, sequencing, and resource allocation<\/li><li>Help maintain project schedules while balancing safety, production, equipment availability, and field conditions<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Significant field experience in mining, heavy civil construction, or large-scale earthmoving operations<\/li><li>Experience working in both mining and heavy civil environments strongly preferred<\/li><li>Previous experience as a Superintendent, General Foreman, Foreman, or similar field leadership position<\/li><li>Demonstrated experience leading equipment operators and field crews<\/li><li>Strong knowledge of excavation, earthmoving, grading, haulage, production, and equipment coordination<\/li><li>Hands-on experience operating heavy equipment such as excavators, dozers, loaders, graders, or haul trucks<\/li><li>Strong mechanical and operational understanding of heavy equipment<\/li><li>Ability to diagnose field problems and make sound operational decisions under pressure<\/li><li>Strong leadership, communication, and personnel-management skills<\/li><li>Working knowledge of MSHA regulations and mining safety practices<\/li><li>Ability to maintain accurate production reports and field documentation<\/li><li>Valid driver's license and ability to travel extensively<\/li><\/ul>\n<p><strong>Travel Requirements<\/strong><\/p>\n<ul><li>This is a heavy-travel position supporting projects in multiple locations<\/li><li>Candidates must be comfortable working extended assignments away from home<\/li><li>Housing will be provided at each project location<\/li><li>Project schedules and rotations may vary depending on operational requirements<\/li><\/ul>\n<p><\/p>\n<p><br>\n\n<\/p>","post_title":"Operations Superintendent &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/operations-superintendent-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"United States","%education%":"","%department%":"TSG","%description%":"<p>We are currently seeking an experienced Operations Superintendent to lead field operations across mining and heavy civil projects. This is a hands-on leadership role for an experienced field professional who can manage crews, coordinate equipment and production, solve operational problems in real time, and step into equipment when necessary to keep the project moving.<\/p>\n<p>This position requires significant travel to project locations. Housing will be provided while assigned to each project.<\/p>\n<p><\/p>\n<p><strong>Position Summary<\/strong><\/p>\n<p>The Operations Superintendent is responsible for the safe, efficient, and productive execution of field operations across mining and heavy civil projects. This individual will oversee crews, equipment, schedules, and day-to-day production while serving as a key field leader between project management and site personnel.<\/p>\n<p>The ideal candidate has a strong combination of mining and heavy civil experience, understands large-scale earthmoving operations, and is comfortable working directly alongside crews in the field. This is not strictly an office-based management position; the Superintendent must be willing and able to troubleshoot field issues, make operational decisions, and operate heavy equipment when needed.<\/p>\n<p><\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Field Operations &amp; Production<\/strong><\/p>\n<ul><li>Lead day-to-day field operations across mining and heavy civil projects<\/li><li>Coordinate manpower, equipment, and resources to meet production and schedule requirements<\/li><li>Develop and execute daily and weekly work plans based on project priorities<\/li><li>Monitor production progress and adjust operations as field conditions change<\/li><li>Identify bottlenecks, equipment limitations, and operational challenges and implement practical field solutions<\/li><li>Maintain a strong field presence and ensure work is progressing safely and efficiently<\/li><li>Coordinate earthmoving, excavation, grading, haulage, site development, and related field activities<\/li><\/ul>\n<p><strong>Crew Leadership<\/strong><\/p>\n<ul><li>Supervise foremen, equipment operators, laborers, and other field personnel<\/li><li>Provide clear direction regarding daily production expectations, work areas, and priorities<\/li><li>Lead pre-shift meetings, toolbox talks, and daily crew assignments<\/li><li>Coach and mentor field personnel to improve safety, productivity, and equipment utilization<\/li><li>Hold crews accountable for production, safety, workmanship, and company standards<\/li><li>Assist with staffing decisions and identify additional manpower or equipment needs<\/li><\/ul>\n<p><strong>Equipment &amp; Hands-On Support<\/strong><\/p>\n<ul><li>Coordinate utilization of heavy equipment including haul trucks, excavators, dozers, loaders, graders, and similar machinery<\/li><li>Ensure equipment is being operated safely and effectively<\/li><li>Recognize mechanical or operational issues and coordinate repairs or maintenance as needed<\/li><li>Assist operators with troubleshooting production or equipment-related challenges<\/li><li>Operate heavy equipment when necessary to support production, cover manpower gaps, or resolve field issues<\/li><li>Work closely with maintenance teams to minimize equipment downtime<\/li><\/ul>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul><li>Promote and enforce a strong safety culture across all field operations<\/li><li>Ensure compliance with MSHA requirements, company policies, and site-specific safety procedures<\/li><li>Conduct field inspections and identify hazards, unsafe conditions, or operational risks<\/li><li>Participate in incident investigations and corrective-action planning when required<\/li><li>Ensure crews consistently follow PPE, equipment, and safe-work requirements<\/li><\/ul>\n<p><strong>Project Coordination<\/strong><\/p>\n<ul><li>Communicate regularly with project managers and senior operations leadership regarding production, manpower, equipment, and project challenges<\/li><li>Coordinate with subcontractors, vendors, maintenance personnel, and client representatives as required<\/li><li>Provide accurate daily production updates, operational reports, and field documentation<\/li><li>Assist with short-term planning, sequencing, and resource allocation<\/li><li>Help maintain project schedules while balancing safety, production, equipment availability, and field conditions<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Significant field experience in mining, heavy civil construction, or large-scale earthmoving operations<\/li><li>Experience working in both mining and heavy civil environments strongly preferred<\/li><li>Previous experience as a Superintendent, General Foreman, Foreman, or similar field leadership position<\/li><li>Demonstrated experience leading equipment operators and field crews<\/li><li>Strong knowledge of excavation, earthmoving, grading, haulage, production, and equipment coordination<\/li><li>Hands-on experience operating heavy equipment such as excavators, dozers, loaders, graders, or haul trucks<\/li><li>Strong mechanical and operational understanding of heavy equipment<\/li><li>Ability to diagnose field problems and make sound operational decisions under pressure<\/li><li>Strong leadership, communication, and personnel-management skills<\/li><li>Working knowledge of MSHA regulations and mining safety practices<\/li><li>Ability to maintain accurate production reports and field documentation<\/li><li>Valid driver's license and ability to travel extensively<\/li><\/ul>\n<p><strong>Travel Requirements<\/strong><\/p>\n<ul><li>This is a heavy-travel position supporting projects in multiple locations<\/li><li>Candidates must be comfortable working extended assignments away from home<\/li><li>Housing will be provided at each project location<\/li><li>Project schedules and rotations may vary depending on operational requirements<\/li><\/ul>\n<p><\/p>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/6cc350d63818-operations-superintendent-traveling","%breezy_id%":"6cc350d63818","%breezy_friendly_id%":"6cc350d63818-operations-superintendent-traveling","%breezy_created_date%":"2026-09-21T19:53:19.360Z","%breezy_updated_date%":"2026-09-21T19:54:19.158Z","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":", TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9685988","%_wpgmp_metabox_longitude%":"-99.9018131","%rank_math_internal_links_processed%":"1"}},"id":4027,"infowindow_disable":false},{"source":"post","title":"Foreman &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Foreman &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are currently seeking an experienced Working Foreman to lead crews and support field operations across mining and heavy civil&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/foreman-traveling\/\" name=\"Foreman &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are currently seeking an experienced Working Foreman to lead crews and support field operations across mining and heavy civil&hellip;","address":", TX, USA","location":{"lat":"31.9685988","state":"TX","country":"United States","lng":"-99.9018131","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/foreman-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"We are currently seeking an experienced Working Foreman to lead crews and support field operations across mining and heavy civil&hellip;","post_content":"<p>We are currently seeking an experienced Working Foreman to lead crews and support field operations across mining and heavy civil projects. This is a hands-on leadership role for someone who can direct crews, coordinate equipment and production, solve problems in the field, and operate heavy equipment alongside the team when needed.<\/p>\n<p>This position requires significant travel to project locations. Housing will be provided while assigned to each project.<\/p>\n<p><\/p>\n<p><strong>Position Summary<\/strong><\/p>\n<p>The Working Foreman is responsible for supervising daily field activities, coordinating labor and equipment, maintaining production goals, and ensuring work is completed safely and efficiently.<\/p>\n<p>The ideal candidate has experience in mining, heavy civil construction, earthwork, or site development and is comfortable leading from the field. This person should understand grading, excavation, haul operations, and equipment utilization and be familiar with GPS and machine-control systems used in modern earthmoving operations.<\/p>\n<p><\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Crew Leadership &amp; Production<\/strong><\/p>\n<ul><li>Lead daily activities of equipment operators, laborers, and field personnel<\/li><li>Assign work areas, equipment, and daily production priorities<\/li><li>Conduct pre-shift meetings, toolbox talks, and crew briefings<\/li><li>Monitor production throughout the shift and adjust work plans as conditions change<\/li><li>Maintain a strong field presence and work directly alongside crews<\/li><li>Identify production issues and implement practical solutions to keep work moving<\/li><li>Communicate manpower, equipment, and material needs to project leadership<\/li><\/ul>\n<p><strong>Heavy Equipment Operations<\/strong><\/p>\n<ul><li>Operate heavy equipment as needed to support field production<\/li><li>Assist with excavation, grading, loading, haulage, and general earthmoving activities<\/li><li>Support crews during manpower shortages, production pushes, or difficult field conditions<\/li><li>Monitor equipment operation and identify potential mechanical or performance issues<\/li><li>Coordinate with maintenance personnel when equipment repairs are required<\/li><li>Ensure operators are using equipment safely and efficiently<\/li><\/ul>\n<p><strong>GPS &amp; Grade Control<\/strong><\/p>\n<ul><li>Work with GPS-enabled equipment and machine-control systems used for grading and excavation<\/li><li>Understand basic site plans, elevations, slopes, cut\/fill requirements, and grade stakes<\/li><li>Assist operators with GPS setup, grade verification, and troubleshooting when needed<\/li><li>Confirm work is being completed to required grades and project specifications<\/li><li>Communicate discrepancies between field conditions, GPS models, and construction plans<\/li><\/ul>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul><li>Enforce company safety policies, site procedures, and applicable MSHA requirements<\/li><li>Identify hazards and correct unsafe conditions before work proceeds<\/li><li>Conduct field inspections of work areas and equipment<\/li><li>Ensure crews follow PPE and safe operating procedures<\/li><li>Participate in incident investigations and corrective-action discussions when required<\/li><li>Promote a strong safety culture through consistent field leadership<\/li><\/ul>\n<p><strong>Project Coordination<\/strong><\/p>\n<ul><li>Coordinate daily activities with Superintendents and Project Managers<\/li><li>Track production quantities, equipment utilization, and crew progress<\/li><li>Maintain daily reports, time records, and field documentation<\/li><li>Coordinate with subcontractors, survey personnel, maintenance teams, and other field personnel<\/li><li>Help sequence work to maintain schedule and production targets<\/li><li>Communicate field changes, delays, and operational issues promptly<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Previous experience as a Foreman, Lead Operator, Working Foreman, or similar field leadership role<\/li><li>Experience in mining, heavy civil construction, earthwork, site development, or similar operations<\/li><li>Strong hands-on experience operating heavy equipment<\/li><li>Experience with equipment such as excavators, dozers, loaders, graders, and haul trucks<\/li><li>Familiarity with GPS and machine-control systems such as Trimble, Topcon, Leica, or similar platforms<\/li><li>Ability to read basic plans, understand elevations, and work to grade<\/li><li>Strong understanding of excavation, grading, haulage, and production operations<\/li><li>Ability to troubleshoot field problems and make sound decisions in real time<\/li><li>Strong leadership and communication skills<\/li><li>Working knowledge of MSHA regulations and mining safety practices preferred<\/li><li>Valid driver's license and ability to travel extensively<\/li><\/ul>\n<p><strong>Travel Requirements<\/strong><\/p>\n<ul><li>This is a heavy-travel position supporting projects in multiple locations<\/li><li>Candidates must be comfortable working extended assignments away from home<\/li><li>Housing will be provided at each project location<\/li><li>Project schedules and rotations may vary depending on operational requirements<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Foreman &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/foreman-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"United States","%education%":"","%department%":"TSG","%description%":"<p>We are currently seeking an experienced Working Foreman to lead crews and support field operations across mining and heavy civil projects. This is a hands-on leadership role for someone who can direct crews, coordinate equipment and production, solve problems in the field, and operate heavy equipment alongside the team when needed.<\/p>\n<p>This position requires significant travel to project locations. Housing will be provided while assigned to each project.<\/p>\n<p><\/p>\n<p><strong>Position Summary<\/strong><\/p>\n<p>The Working Foreman is responsible for supervising daily field activities, coordinating labor and equipment, maintaining production goals, and ensuring work is completed safely and efficiently.<\/p>\n<p>The ideal candidate has experience in mining, heavy civil construction, earthwork, or site development and is comfortable leading from the field. This person should understand grading, excavation, haul operations, and equipment utilization and be familiar with GPS and machine-control systems used in modern earthmoving operations.<\/p>\n<p><\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Crew Leadership &amp; Production<\/strong><\/p>\n<ul><li>Lead daily activities of equipment operators, laborers, and field personnel<\/li><li>Assign work areas, equipment, and daily production priorities<\/li><li>Conduct pre-shift meetings, toolbox talks, and crew briefings<\/li><li>Monitor production throughout the shift and adjust work plans as conditions change<\/li><li>Maintain a strong field presence and work directly alongside crews<\/li><li>Identify production issues and implement practical solutions to keep work moving<\/li><li>Communicate manpower, equipment, and material needs to project leadership<\/li><\/ul>\n<p><strong>Heavy Equipment Operations<\/strong><\/p>\n<ul><li>Operate heavy equipment as needed to support field production<\/li><li>Assist with excavation, grading, loading, haulage, and general earthmoving activities<\/li><li>Support crews during manpower shortages, production pushes, or difficult field conditions<\/li><li>Monitor equipment operation and identify potential mechanical or performance issues<\/li><li>Coordinate with maintenance personnel when equipment repairs are required<\/li><li>Ensure operators are using equipment safely and efficiently<\/li><\/ul>\n<p><strong>GPS &amp; Grade Control<\/strong><\/p>\n<ul><li>Work with GPS-enabled equipment and machine-control systems used for grading and excavation<\/li><li>Understand basic site plans, elevations, slopes, cut\/fill requirements, and grade stakes<\/li><li>Assist operators with GPS setup, grade verification, and troubleshooting when needed<\/li><li>Confirm work is being completed to required grades and project specifications<\/li><li>Communicate discrepancies between field conditions, GPS models, and construction plans<\/li><\/ul>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul><li>Enforce company safety policies, site procedures, and applicable MSHA requirements<\/li><li>Identify hazards and correct unsafe conditions before work proceeds<\/li><li>Conduct field inspections of work areas and equipment<\/li><li>Ensure crews follow PPE and safe operating procedures<\/li><li>Participate in incident investigations and corrective-action discussions when required<\/li><li>Promote a strong safety culture through consistent field leadership<\/li><\/ul>\n<p><strong>Project Coordination<\/strong><\/p>\n<ul><li>Coordinate daily activities with Superintendents and Project Managers<\/li><li>Track production quantities, equipment utilization, and crew progress<\/li><li>Maintain daily reports, time records, and field documentation<\/li><li>Coordinate with subcontractors, survey personnel, maintenance teams, and other field personnel<\/li><li>Help sequence work to maintain schedule and production targets<\/li><li>Communicate field changes, delays, and operational issues promptly<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Previous experience as a Foreman, Lead Operator, Working Foreman, or similar field leadership role<\/li><li>Experience in mining, heavy civil construction, earthwork, site development, or similar operations<\/li><li>Strong hands-on experience operating heavy equipment<\/li><li>Experience with equipment such as excavators, dozers, loaders, graders, and haul trucks<\/li><li>Familiarity with GPS and machine-control systems such as Trimble, Topcon, Leica, or similar platforms<\/li><li>Ability to read basic plans, understand elevations, and work to grade<\/li><li>Strong understanding of excavation, grading, haulage, and production operations<\/li><li>Ability to troubleshoot field problems and make sound decisions in real time<\/li><li>Strong leadership and communication skills<\/li><li>Working knowledge of MSHA regulations and mining safety practices preferred<\/li><li>Valid driver's license and ability to travel extensively<\/li><\/ul>\n<p><strong>Travel Requirements<\/strong><\/p>\n<ul><li>This is a heavy-travel position supporting projects in multiple locations<\/li><li>Candidates must be comfortable working extended assignments away from home<\/li><li>Housing will be provided at each project location<\/li><li>Project schedules and rotations may vary depending on operational requirements<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/793d55488f8d-foreman-traveling","%breezy_id%":"793d55488f8d","%breezy_friendly_id%":"793d55488f8d-foreman-traveling","%breezy_created_date%":"2026-09-21T19:56:41.329Z","%breezy_updated_date%":"2026-09-21T19:57:17.233Z","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":", TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9685988","%_wpgmp_metabox_longitude%":"-99.9018131","%rank_math_internal_links_processed%":"1"}},"id":4028,"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    Heavy Equipment Operator As Heavy Equipment Operator you sit in the cab that makes every cubic meter count\u2014safe, precise, on&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-6\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Operator As Heavy Equipment Operator you sit in the cab that makes every cubic meter count\u2014safe, precise, on&hellip;","address":"Sylacauga, AL, USA","location":{"lat":"33.1731716","city":"Sylacauga","state":"AL","country":"United States","lng":"-86.2516406","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Operator As Heavy Equipment Operator you sit in the cab that makes every cubic meter count\u2014safe, precise, on&hellip;","post_content":"<h1 style=\"line-height:1.5;margin:0px\">Heavy Equipment Operator<\/h1><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">As Heavy Equipment Operator you sit in the cab that makes every cubic meter count\u2014safe, precise, on schedule\u2014so our mining, earthworks, and construction crews can keep delivering for clients who trust us with their most demanding sites.<\/p><h2 style=\"line-height:1.5;margin:0px\"><br><\/h2><h2 style=\"line-height:1.5;margin:0px\">Performance Objectives<\/h2><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Complete assigned earthmoving, grading, and extraction cycles 10\u201315 % faster than site baseline while recording zero lost-time incidents each month.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain 95 %+ equipment availability by performing daily inspections, reporting defects immediately, and executing first-line servicing on CAT, Komatsu, and similar machines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Achieve design grades and cut\/fill tolerances within 2 cm on 90 % of surveyed sections, reducing rework and fuel waste.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support urbanization and hydraulic projects by coordinating with surveyors and civil teams to place material exactly where drawings specify, first time.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Log every shift in the digital work-order system so superintendents have real-time production data for client reporting.<\/li>\n<\/ul><h2 style=\"line-height:1.5;margin:0px\"><br><\/h2><h2 style=\"line-height:1.5;margin:0px\">Environment &amp; Resources<\/h2><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">You report to the Site Superintendent and work alongside a tight crew of operators, mechanics, and surveyors on active mining, road, and construction sites. You have access to well-maintained heavy plant, GPS machine-control systems, and a dedicated maintenance team. Safety gear, fuel, and consumables are supplied; you own the cab and the outcome.<\/p><h2 style=\"line-height:1.5;margin:0px\"><br><\/h2><h2 style=\"line-height:1.5;margin:0px\">Essential Qualifications<\/h2><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proven ability to operate excavators, dozers, loaders, and graders on mining or heavy-civil projects for at least four years, with documented production records.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Track record of zero preventable incidents over the last 24 months and fluency with daily pre-start checklists.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comfort reading grade stakes, GPS screens, and basic construction drawings.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willingness to work rotating shifts<\/li>\n<\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%experience%":"","%location_country%":"United States","%location_city%":"Sylacauga","%location_state_id%":"AL","%location_state_name%":"Alabama","%location_city_state%":"Sylacauga, AL","%education%":"","%department%":"TSG","%description%":"<h1 style=\"line-height:1.5;margin:0px;\">Heavy Equipment Operator<\/h1><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">As Heavy Equipment Operator you sit in the cab that makes every cubic meter count\u2014safe, precise, on schedule\u2014so our mining, earthworks, and construction crews can keep delivering for clients who trust us with their most demanding sites.<\/p><h2 style=\"line-height:1.5;margin:0px;\"><br><\/h2><h2 style=\"line-height:1.5;margin:0px;\">Performance Objectives<\/h2><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Complete assigned earthmoving, grading, and extraction cycles 10\u201315 % faster than site baseline while recording zero lost-time incidents each month.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain 95 %+ equipment availability by performing daily inspections, reporting defects immediately, and executing first-line servicing on CAT, Komatsu, and similar machines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Achieve design grades and cut\/fill tolerances within 2 cm on 90 % of surveyed sections, reducing rework and fuel waste.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support urbanization and hydraulic projects by coordinating with surveyors and civil teams to place material exactly where drawings specify, first time.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Log every shift in the digital work-order system so superintendents have real-time production data for client reporting.<\/li>\n<\/ul><h2 style=\"line-height:1.5;margin:0px;\"><br><\/h2><h2 style=\"line-height:1.5;margin:0px;\">Environment &amp; Resources<\/h2><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">You report to the Site Superintendent and work alongside a tight crew of operators, mechanics, and surveyors on active mining, road, and construction sites. You have access to well-maintained heavy plant, GPS machine-control systems, and a dedicated maintenance team. Safety gear, fuel, and consumables are supplied; you own the cab and the outcome.<\/p><h2 style=\"line-height:1.5;margin:0px;\"><br><\/h2><h2 style=\"line-height:1.5;margin:0px;\">Essential Qualifications<\/h2><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proven ability to operate excavators, dozers, loaders, and graders on mining or heavy-civil projects for at least four years, with documented production records.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Track record of zero preventable incidents over the last 24 months and fluency with daily pre-start checklists.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comfort reading grade stakes, GPS screens, and basic construction drawings.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willingness to work rotating shifts<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/cc29487aa4e6-heavy-equipment-operator","%breezy_id%":"cc29487aa4e6","%breezy_friendly_id%":"cc29487aa4e6-heavy-equipment-operator","%breezy_created_date%":"2026-09-21T21:03:22.976Z","%breezy_updated_date%":"2026-09-21T21:03:25.098Z","%_wpgmp_location_city%":"Sylacauga","%_wpgmp_location_state%":"AL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Sylacauga, AL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.1731716","%_wpgmp_metabox_longitude%":"-86.2516406","%rank_math_internal_links_processed%":"1"}},"id":4029,"infowindow_disable":false},{"source":"post","title":"Senior Environmental Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Environmental Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Sr. Environmental Specialist &#8211; Hobbs, NM\/Carlsbad, NM Come grow with us! Drive environmental excellence. Lead meaningful work. Make an impact.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-environmental-specialist\/\" name=\"Senior Environmental Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Sr. Environmental Specialist &#8211; Hobbs, NM\/Carlsbad, NM Come grow with us! Drive environmental excellence. Lead meaningful work. Make an impact.&hellip;","address":"Carlsbad, NM, USA","location":{"lat":"32.4203395","city":"Carlsbad","state":"NM","country":"United States","lng":"-104.2289925","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-environmental-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"Sr. Environmental Specialist &#8211; Hobbs, NM\/Carlsbad, NM Come grow with us! Drive environmental excellence. Lead meaningful work. Make an impact.&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Sr. Environmental Specialist - Hobbs, NM\/Carlsbad, NM<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Come grow with us!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Drive environmental excellence. Lead meaningful work. Make an impact.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>How You Will Create Value<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">As the Senior Environmental Scientist, you\u2019ll take a lead role with environmental<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">compliance across air, water and waste for Intrepid\u2019s largest worksite. This isn\u2019t just a job<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">ticking compliance boxes, you will also help shape and advance environmental best<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">practices across the organization, as we continue to scale as an organization.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You\u2019ll Need to Be Successful?<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Demonstrated proficiency leading and advancing environmental initiatives in<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">dynamic environments.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Ability to balance both strategy and \u201chands on\u201d field execution. You must be<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">comfortable shifting between a climate-controlled office and rugged industrial field<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">locations, including processing facilities and construction sites.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Working knowledge of the Clean Water Act, Clean Air Act, Resource Conversation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">and Recovery Act, NEPA, MSHA, OSHA, and other applicable regulatory<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Analytical thinking, attention to detail, and the ability to generate solutions using<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">sound judgement. Must be able to effectively gather, synthesize, analyze and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">package\/present environmental information to internal and external stakeholders.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Demonstrated ability to inspire confidence and trust as a competent team player.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Because time will be required in the field, you will be required to walk\/stand for<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">longer periods of time, lift up 50 pounds occasionally, climb, etc. (physical activity)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Why Work for us?<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 We impact lives for the better. Our efforts as a solution miner are essential for<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">agriculture, animal feed, and other industrial operations such as oil and gas.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Our quality, agility, reliability, and speed differentiate us with customers. We act<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">with integrity and trust.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 We are financially healthy with strong revenue, cash flow, and no long-term debt.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 We have both a proud history and a compelling future, focused on sustainable and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">superior operational excellence and customer service.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 We have some great benefits, including a 9\/80 work schedule with every other<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Friday off.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">For more information, and to apply online, visit www.intrepidpotash.jobs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The above declarations are not intended to be an all-inclusive list of the duties and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">responsibilities of the job described, nor are they intended to be such a listing of the skills<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">and abilities required to do the job. Rather, they are intended only to describe the general<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">nature of the job.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Senior Environmental Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/senior-environmental-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Carlsbad","%location_state_id%":"NM","%location_state_name%":"New Mexico","%location_city_state%":"Carlsbad, NM","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Sr. Environmental Specialist - Hobbs, NM\/Carlsbad, NM<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Come grow with us!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Drive environmental excellence. Lead meaningful work. Make an impact.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>How You Will Create Value<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">As the Senior Environmental Scientist, you\u2019ll take a lead role with environmental<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">compliance across air, water and waste for Intrepid\u2019s largest worksite. This isn\u2019t just a job<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">ticking compliance boxes, you will also help shape and advance environmental best<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">practices across the organization, as we continue to scale as an organization.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You\u2019ll Need to Be Successful?<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Demonstrated proficiency leading and advancing environmental initiatives in<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">dynamic environments.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Ability to balance both strategy and \u201chands on\u201d field execution. You must be<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">comfortable shifting between a climate-controlled office and rugged industrial field<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">locations, including processing facilities and construction sites.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Working knowledge of the Clean Water Act, Clean Air Act, Resource Conversation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">and Recovery Act, NEPA, MSHA, OSHA, and other applicable regulatory<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Analytical thinking, attention to detail, and the ability to generate solutions using<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">sound judgement. Must be able to effectively gather, synthesize, analyze and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">package\/present environmental information to internal and external stakeholders.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Demonstrated ability to inspire confidence and trust as a competent team player.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Because time will be required in the field, you will be required to walk\/stand for<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">longer periods of time, lift up 50 pounds occasionally, climb, etc. (physical activity)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Why Work for us?<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 We impact lives for the better. Our efforts as a solution miner are essential for<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">agriculture, animal feed, and other industrial operations such as oil and gas.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Our quality, agility, reliability, and speed differentiate us with customers. We act<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">with integrity and trust.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 We are financially healthy with strong revenue, cash flow, and no long-term debt.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 We have both a proud history and a compelling future, focused on sustainable and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">superior operational excellence and customer service.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 We have some great benefits, including a 9\/80 work schedule with every other<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Friday off.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">For more information, and to apply online, visit www.intrepidpotash.jobs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The above declarations are not intended to be an all-inclusive list of the duties and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">responsibilities of the job described, nor are they intended to be such a listing of the skills<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">and abilities required to do the job. Rather, they are intended only to describe the general<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">nature of the job.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/03ee44c56ef1-senior-environmental-specialist","%breezy_id%":"03ee44c56ef1","%breezy_friendly_id%":"03ee44c56ef1-senior-environmental-specialist","%breezy_created_date%":"2026-09-21T14:24:34.048Z","%breezy_updated_date%":"2026-09-21T14:24:45.420Z","%_wpgmp_location_city%":"Carlsbad","%_wpgmp_location_state%":"NM","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Carlsbad, NM, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.4203395","%_wpgmp_metabox_longitude%":"-104.2289925","%rank_math_internal_links_processed%":"1"}},"id":4026,"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 seeking heavy equipment operators to work in a team-oriented, safety-first environment.Job Description: &nbsp; ESSENTIAL DUTIES: Operate heavy earth-moving&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 seeking heavy equipment operators to work in a team-oriented, safety-first environment.Job Description: &nbsp; ESSENTIAL DUTIES: Operate heavy earth-moving&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-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking heavy equipment operators to work in a team-oriented, safety-first environment.Job Description: &nbsp; ESSENTIAL DUTIES: Operate heavy earth-moving&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are seeking heavy equipment operators to work in a team-oriented, safety-first environment.<strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>ESSENTIAL DUTIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate heavy earth-moving equipment, such as dozers, excavators, loaders, mining trucks, scrapers and more in all aspects of mining.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform proper equipment startup and shutdown procedures along with daily servicing of equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate within the acceptable range of design capabilities of the equipment, aided by instrumentation gauges and indicators.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform all job duties in accordance with MSHA laws and regulations, established company safety policies and state and federal environmental regulations in a safe and efficient manner consistent with North American Mining standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Practice defensive driving and equipment operation at all times.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>OTHER DUTIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work with other equipment operators in a safe and organized manner and within established traffic plans.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist in water management, construction, labor, and maintenance activities as necessary.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform utility work and operate utility equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist the maintenance department with routine repairs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Keep the supervisor informed of any potential problems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>KNOWLEDGE, SKILLS, AND ABILITIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Possess basic mechanical knowledge of heavy equipment to assess condition and prevent damage.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate equipment properly within tolerances.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with preventive maintenance and servicing as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work with GPS units in the equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge and ability to respond to emergencies and unpredictable situations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to recognize unsafe and adverse conditions and the knowledge to correct or report them.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability and willingness to work rotating shifts up to 12 hours per shift, including night shifts and weekends.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>EDUCATION AND TRAINING:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High school diploma or GED. Relevant experience may be substituted.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Two years of experience operating heavy off-road construction equipment is a plus.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>ANALYSIS OF PHYSICAL DEMANDS OF POSITION:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Intermittently:<\/strong> lifting and carrying 50 lbs. (tools and supplies); pushing 50 lbs. (making mechanical repairs).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Occasionally<\/strong> <strong>(0 \u2013 1\/3 of workday):<\/strong> standing and walking (maintenance and cleaning); pulling 50 lbs. (making mechanical repairs); climbing and balancing (on and off equipment, light plants); stooping, kneeling, crouching, crawling (inspection and repairs); reaching (equipment operation).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Frequently (1\/3 \u2013 2\/3 of workday):<\/strong> finger repetitive motion (controls, computer); speaking (communications, radio); color vision (identification of strata).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Continually (2\/3 \u2013 3\/3 of workday):<\/strong> depth perception and sitting (equipment operation); handling (controls); hearing (equipment problem detection, radio, hazard recognition); seeing (equipment operation, hazard recognition).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>WORKING CONDITIONS:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must work rotating shifts, with some work being performed outside in all weather conditions with frequent exposure to disagreeable elements and hazards including heights.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>EEO Statement:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are an equal opportunity employer and we do not discriminate. You must meet at least the specific minimum requirements listed above to be considered a qualified applicant.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","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%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are seeking heavy equipment operators to work in a team-oriented, safety-first environment.<strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>ESSENTIAL DUTIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate heavy earth-moving equipment, such as dozers, excavators, loaders, mining trucks, scrapers and more in all aspects of mining.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform proper equipment startup and shutdown procedures along with daily servicing of equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate within the acceptable range of design capabilities of the equipment, aided by instrumentation gauges and indicators.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform all job duties in accordance with MSHA laws and regulations, established company safety policies and state and federal environmental regulations in a safe and efficient manner consistent with North American Mining standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Practice defensive driving and equipment operation at all times.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>OTHER DUTIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work with other equipment operators in a safe and organized manner and within established traffic plans.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist in water management, construction, labor, and maintenance activities as necessary.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform utility work and operate utility equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist the maintenance department with routine repairs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Keep the supervisor informed of any potential problems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>KNOWLEDGE, SKILLS, AND ABILITIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Possess basic mechanical knowledge of heavy equipment to assess condition and prevent damage.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate equipment properly within tolerances.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with preventive maintenance and servicing as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work with GPS units in the equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge and ability to respond to emergencies and unpredictable situations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to recognize unsafe and adverse conditions and the knowledge to correct or report them.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability and willingness to work rotating shifts up to 12 hours per shift, including night shifts and weekends.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>EDUCATION AND TRAINING:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High school diploma or GED. Relevant experience may be substituted.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Two years of experience operating heavy off-road construction equipment is a plus.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>ANALYSIS OF PHYSICAL DEMANDS OF POSITION:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Intermittently:<\/strong> lifting and carrying 50 lbs. (tools and supplies); pushing 50 lbs. (making mechanical repairs).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Occasionally<\/strong> <strong>(0 \u2013 1\/3 of workday):<\/strong> standing and walking (maintenance and cleaning); pulling 50 lbs. (making mechanical repairs); climbing and balancing (on and off equipment, light plants); stooping, kneeling, crouching, crawling (inspection and repairs); reaching (equipment operation).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Frequently (1\/3 \u2013 2\/3 of workday):<\/strong> finger repetitive motion (controls, computer); speaking (communications, radio); color vision (identification of strata).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Continually (2\/3 \u2013 3\/3 of workday):<\/strong> depth perception and sitting (equipment operation); handling (controls); hearing (equipment problem detection, radio, hazard recognition); seeing (equipment operation, hazard recognition).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>WORKING CONDITIONS:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must work rotating shifts, with some work being performed outside in all weather conditions with frequent exposure to disagreeable elements and hazards including heights.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>EEO Statement:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are an equal opportunity employer and we do not discriminate. You must meet at least the specific minimum requirements listed above to be considered a qualified applicant.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/f317f81a1908-heavy-equipment-operator","%breezy_id%":"f317f81a1908","%breezy_friendly_id%":"f317f81a1908-heavy-equipment-operator","%breezy_created_date%":"2026-09-16T22:04:13.698Z","%breezy_updated_date%":"2026-09-16T22:04:15.696Z","%_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"}},"id":4016,"infowindow_disable":false},{"source":"post","title":"Operations Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Operations Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This position will oversee and supervise a group of workforce employees in a skilled area of production and maintenance while&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/operations-supervisor\/\" name=\"Operations Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This position will oversee and supervise a group of workforce employees in a skilled area of production and maintenance while&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\/operations-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"This position will oversee and supervise a group of workforce employees in a skilled area of production and maintenance while&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position will oversee and supervise a group of workforce employees in a skilled area of production and maintenance while maintaining morale, attendance, safety, and environmental compliance. The work duties to be performed by the work group include construction activities and early mining. This position requires performing administrative duties, including developing and maintaining records and other pertinent office functions associated with workforce supervision.  Specific duties may focus on operations or maintenance.<strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Essential Duties:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Supervises the daily activities of heavy equipment operators and\/or maintenance personnel to facilitate the required production.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Effectively plans and schedules production and\/or maintenance work using personnel, materials, and equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinates all safety activities to ensure proper training for personnel and maintain or exceed compliance with North American Mining and MSHA safety standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensures the group's work takes place in a safe and efficient working environment using safe and efficient work practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensures the work of the group adheres to established environmental standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Performs administrative duties associated with supervision, such as ensuring accurate time records and assessing individual performance, including attendance, counseling, and correcting unacceptable behavior.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinates work with other departments and shifts to minimize downtime and maximize productivity.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintains productivity records to establish current and future production schedules, maintenance costs, and predict equipment availability.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Performs job duties by following MSHA laws and regulations, established company safety procedures, and state and federal environmental regulations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Other Duties:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provides high-level training to employees on equipment and tools to meet or exceed MSHA requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Performs other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Knowledge, Skills, and Abilities:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of large industrial earth-moving equipment capabilities and application.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have strong verbal, written, and interpersonal communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of MSHA regulations, general safety practices, and environmental standards for mining.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to effectively direct the work of crew members to perform safely and efficiently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to build and maintain a positive work environment that encourages open communication.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work with confidential information and situations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Basic computer skills, to include Microsoft Office Suite.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to perform in a rotating shift schedule environment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Education and Experience:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Supervisory experience or training in areas of supervision is required. MSHA IS certification a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Minimum 3-5 years of related experience is necessary for someone to start in this position. A college degree may be substituted for up to 3 years of experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Vocational technical training and\/or 3-5 years of experience in surface mining may be required depending on supervision area. Additional past work experience may be considered equivalent.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>ANALYSIS OF PHYSICAL DEMANDS OF POSITION<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Intermittently:<\/strong> Lifting, carrying, and pulling up to 50 lbs. (tow cables, field inspection tools, equipment and field supplies, related activities).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Occasionally (0 \u2013 1\/3 of workday):<\/strong> Pushing up to 50 lbs. (light plants); stooping, kneeling, crouching (equipment inspections, field reviews, observations); crawling (accessing confined areas of equipment); reaching (vehicle operation, inspections); handling (tools, controls, documents); repetitive finger motion (computer use, reporting, data entry); standing (work area inspections, meetings, field observations); walking(equipment and worksite inspections); sitting (administrative work, scheduling, reports).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Frequently (1\/3 \u2013 2\/3 of workday): <\/strong>Depth perception (equipment operations and field inspections); color vision (survey markings, lighting systems, safety indicators); climbing (accessing heavy equipment, elevated work areas); balancing (working on equipment and uneven ground).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Constantly (2\/3 \u2013 3\/3 of workday): <\/strong>Speaking (crew direction, radio communication, safety meetings); hearing (radio communications, hazard awareness); seeing (safety monitoring, inspections, equipment observations).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>WORKING CONDITIONS<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work is performed in office and active mining environments with exposure to weather, dust, noise, heavy equipment, and other mining hazards. Required PPE must be worn. Must work rotating shifts, with some work being performed outside in all weather conditions.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>EEO Statement:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are an equal opportunity employer and we do not discriminate. You must meet at least the specific minimum requirements listed above to be considered a qualified applicant.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Operations Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/operations-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position will oversee and supervise a group of workforce employees in a skilled area of production and maintenance while maintaining morale, attendance, safety, and environmental compliance. The work duties to be performed by the work group include construction activities and early mining. This position requires performing administrative duties, including developing and maintaining records and other pertinent office functions associated with workforce supervision.  Specific duties may focus on operations or maintenance.<strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Essential Duties:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Supervises the daily activities of heavy equipment operators and\/or maintenance personnel to facilitate the required production.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Effectively plans and schedules production and\/or maintenance work using personnel, materials, and equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinates all safety activities to ensure proper training for personnel and maintain or exceed compliance with North American Mining and MSHA safety standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensures the group's work takes place in a safe and efficient working environment using safe and efficient work practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensures the work of the group adheres to established environmental standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Performs administrative duties associated with supervision, such as ensuring accurate time records and assessing individual performance, including attendance, counseling, and correcting unacceptable behavior.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinates work with other departments and shifts to minimize downtime and maximize productivity.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintains productivity records to establish current and future production schedules, maintenance costs, and predict equipment availability.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Performs job duties by following MSHA laws and regulations, established company safety procedures, and state and federal environmental regulations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Other Duties:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provides high-level training to employees on equipment and tools to meet or exceed MSHA requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Performs other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Knowledge, Skills, and Abilities:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of large industrial earth-moving equipment capabilities and application.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have strong verbal, written, and interpersonal communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of MSHA regulations, general safety practices, and environmental standards for mining.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to effectively direct the work of crew members to perform safely and efficiently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to build and maintain a positive work environment that encourages open communication.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work with confidential information and situations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Basic computer skills, to include Microsoft Office Suite.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to perform in a rotating shift schedule environment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Education and Experience:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Supervisory experience or training in areas of supervision is required. MSHA IS certification a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Minimum 3-5 years of related experience is necessary for someone to start in this position. A college degree may be substituted for up to 3 years of experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Vocational technical training and\/or 3-5 years of experience in surface mining may be required depending on supervision area. Additional past work experience may be considered equivalent.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>ANALYSIS OF PHYSICAL DEMANDS OF POSITION<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Intermittently:<\/strong> Lifting, carrying, and pulling up to 50 lbs. (tow cables, field inspection tools, equipment and field supplies, related activities).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Occasionally (0 \u2013 1\/3 of workday):<\/strong> Pushing up to 50 lbs. (light plants); stooping, kneeling, crouching (equipment inspections, field reviews, observations); crawling (accessing confined areas of equipment); reaching (vehicle operation, inspections); handling (tools, controls, documents); repetitive finger motion (computer use, reporting, data entry); standing (work area inspections, meetings, field observations); walking(equipment and worksite inspections); sitting (administrative work, scheduling, reports).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Frequently (1\/3 \u2013 2\/3 of workday): <\/strong>Depth perception (equipment operations and field inspections); color vision (survey markings, lighting systems, safety indicators); climbing (accessing heavy equipment, elevated work areas); balancing (working on equipment and uneven ground).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Constantly (2\/3 \u2013 3\/3 of workday): <\/strong>Speaking (crew direction, radio communication, safety meetings); hearing (radio communications, hazard awareness); seeing (safety monitoring, inspections, equipment observations).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>WORKING CONDITIONS<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work is performed in office and active mining environments with exposure to weather, dust, noise, heavy equipment, and other mining hazards. Required PPE must be worn. Must work rotating shifts, with some work being performed outside in all weather conditions.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>EEO Statement:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are an equal opportunity employer and we do not discriminate. You must meet at least the specific minimum requirements listed above to be considered a qualified applicant.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/392726e544e3-operations-supervisor","%breezy_id%":"392726e544e3","%breezy_friendly_id%":"392726e544e3-operations-supervisor","%breezy_created_date%":"2026-09-16T22:08:37.961Z","%breezy_updated_date%":"2026-09-16T22:08:39.872Z","%_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"}},"id":4017,"infowindow_disable":false},{"source":"post","title":"Mining Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Support a safety-first team maintaining and repairing large-scale mining equipment as a heavy equipment mechanic within a growing mining operation.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-equipment-mechanic\/\" name=\"Mining Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Support a safety-first team maintaining and repairing large-scale mining equipment as a heavy equipment mechanic within a growing mining operation.&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-equipment-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Support a safety-first team maintaining and repairing large-scale mining equipment as a heavy equipment mechanic within a growing mining operation.&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support a safety-first team maintaining and repairing large-scale mining equipment as a heavy equipment mechanic within a growing mining operation. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are looking for a skilled professional who prioritizes safety and is enthusiastic about maintaining, diagnosing, and repairing heavy-duty mining equipment. This hands-on role will play a critical role in keeping operations running at peak performance at the Thacker Pass Lithium Project. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">You\u2019ll work alongside an experienced team performing preventative maintenance, troubleshooting mechanical issues, and rebuilding equipment as needed. This role is for a mechanic who takes pride in their work and values reliability and teamwork. With your contributions, the team will create a safer and more productive work environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">At Sawtooth Mining, we\u2019ve got your back, providing all the tools and coveralls you need to succeed. Together, we can make a meaningful impact. Apply today!<strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Essential Duties:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform preventive maintenance such as changing oil, greasing, and replacing components on a scheduled basis.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Troubleshoot\/diagnose heavy equipment malfunctions and replace parts, repair, and rebuild as necessary.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Dismantle and reassemble equipment using hoists and hand tools.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Read blueprints and follow service manuals and parts lists in setting up and performing repairs and any rebuilds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Utilize work orders and requisitions for ordering parts and maintenance of equipment cost records.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Advise when immediate shutdown of equipment is necessary to minimize damage or when continued operation will have harmful effect.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform job duties following MSHA law and regulations, established company safety procedures, and state and federal environmental regulations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Other duties:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Fuel and lube equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate the equipment to diagnose problems and test and operate after repair.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate light vehicles to travel throughout the mine site.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain shop area with proper housekeeping for a safe work environment.&nbsp;Ensure vehicles and tools are clean and properly maintained.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Knowledge, Skills, and Abilities:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong work ethic with effective communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have a background in repair and maintenance of heavy equipment, including the ability to read, understand, and use prints and manuals.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must possess knowledge of mechanical, i.e., engine, transmission, drive train, pneumatic, hydraulic components, brake, and air conditioning systems, and skills in diagnosing malfunctions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Rotating shift work is required, and must be able to work up to 12-hour shifts.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Education and Training:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Two years of maintenance experience or a technical degree is required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">A high school diploma or GED is required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must pass the necessary written and practical tests for this position.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>EEO Statement:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are an equal opportunity employer and we do not discriminate. You must meet at least the specific minimum requirements listed above to be considered a qualified applicant.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Mining Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mining-equipment-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support a safety-first team maintaining and repairing large-scale mining equipment as a heavy equipment mechanic within a growing mining operation. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are looking for a skilled professional who prioritizes safety and is enthusiastic about maintaining, diagnosing, and repairing heavy-duty mining equipment. This hands-on role will play a critical role in keeping operations running at peak performance at the Thacker Pass Lithium Project. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">You\u2019ll work alongside an experienced team performing preventative maintenance, troubleshooting mechanical issues, and rebuilding equipment as needed. This role is for a mechanic who takes pride in their work and values reliability and teamwork. With your contributions, the team will create a safer and more productive work environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">At Sawtooth Mining, we\u2019ve got your back, providing all the tools and coveralls you need to succeed. Together, we can make a meaningful impact. Apply today!<strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Essential Duties:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform preventive maintenance such as changing oil, greasing, and replacing components on a scheduled basis.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Troubleshoot\/diagnose heavy equipment malfunctions and replace parts, repair, and rebuild as necessary.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Dismantle and reassemble equipment using hoists and hand tools.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Read blueprints and follow service manuals and parts lists in setting up and performing repairs and any rebuilds.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Utilize work orders and requisitions for ordering parts and maintenance of equipment cost records.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Advise when immediate shutdown of equipment is necessary to minimize damage or when continued operation will have harmful effect.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform job duties following MSHA law and regulations, established company safety procedures, and state and federal environmental regulations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Other duties:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Fuel and lube equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate the equipment to diagnose problems and test and operate after repair.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate light vehicles to travel throughout the mine site.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain shop area with proper housekeeping for a safe work environment.&nbsp;Ensure vehicles and tools are clean and properly maintained.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Knowledge, Skills, and Abilities:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong work ethic with effective communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have a background in repair and maintenance of heavy equipment, including the ability to read, understand, and use prints and manuals.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must possess knowledge of mechanical, i.e., engine, transmission, drive train, pneumatic, hydraulic components, brake, and air conditioning systems, and skills in diagnosing malfunctions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Rotating shift work is required, and must be able to work up to 12-hour shifts.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Education and Training:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Two years of maintenance experience or a technical degree is required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">A high school diploma or GED is required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must pass the necessary written and practical tests for this position.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>EEO Statement:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are an equal opportunity employer and we do not discriminate. You must meet at least the specific minimum requirements listed above to be considered a qualified applicant.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/cc4958adbde6-mining-equipment-mechanic","%breezy_id%":"cc4958adbde6","%breezy_friendly_id%":"cc4958adbde6-mining-equipment-mechanic","%breezy_created_date%":"2026-09-16T21:50:24.128Z","%breezy_updated_date%":"2026-09-16T21:50:26.447Z","%_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"}},"id":4014,"infowindow_disable":false},{"source":"post","title":"Surveyor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Surveyor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    JOB SUMMARY: This position is responsible for conducting ground and unmanned aerial surveys, processing and managing survey data, and providing&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/surveyor\/\" name=\"Surveyor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"JOB SUMMARY: This position is responsible for conducting ground and unmanned aerial surveys, processing and managing survey data, and providing&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\/","zoom":19,"extra_fields":{"post_excerpt":"JOB SUMMARY: This position is responsible for conducting ground and unmanned aerial surveys, processing and managing survey data, and providing&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">JOB SUMMARY:<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position is responsible for conducting ground and unmanned aerial surveys, processing and managing survey data, and providing AutoCAD drafting support for mining operations. The role installs, maintains, and troubleshoots machine control systems to ensure accurate positioning and operational efficiency. Working closely with engineering, geology, and operations teams, the incumbent provides surveying and technical support essential to mine planning, development, and production activities, while adhering to all safety and regulatory requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Location: Thacker Pass Project in Orovada, NV.<strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>ESSENTIAL DUTIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform job duties in accordance with MSHA law and regulations, established company safety procedures, and state and federal environmental regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Collect field data using GPS and traditional surveying equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Calculate volumes moved by equipment, including stockpile volumes, truck\/shovel yards, pond capacities, etc.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Establish control and targets for aerial surveys.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Pilot UAS (Unmanned Aircraft System) for aerial surveys and process data to produce topographic maps, calculate quantities, and produce aerial photos.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform CAD applications such as volume computations, haul\/ramp designs, and 3-D modeling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Manage data in spreadsheets as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Calculate monthly pit inventory and ore severed for royalty payments, as well as end-of-month reports and maps.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Construction staking of haul roads, ponds, boundaries, etc.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>OTHER DUTIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Create GPS files for equipment in the operations department.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Draft using AutoCAD for mapping, permitting, mine plans, etc.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Install, maintain, and calibrate surveying and machine control equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide various survey support to departments for special projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>KNOWLEDGE, SKILLS, AND ABILITIES<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work independently or cooperatively with co-workers on projects while organizing day-to-day activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of land surveying and engineering principles and practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proficient in technology (AutoCAD, Carlson\/Trimble, Microsoft 365).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Good verbal and written communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with surveying at a surface mining operation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work safely in all weather conditions.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>EDUCATION AND EXPERIENCE:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">A Minimum of two years of post-secondary education in civil engineering technology, surveying, or a related discipline and\/or appropriate surveying and computer experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Additional relevant surveying experience preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">An FAA Part 107 drone license is required or must be obtained within 60 days of hire.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>ANALYSIS OF PHYSICAL DEMANDS OF POSITION:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Intermittently:<\/strong> None<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Occasionally<\/strong> <strong>(0 \u2013 1\/3 of workday):<\/strong> lifting to 60 lbs. (lath, GPS equipment, briefcase); pushing and pulling 30 lbs. (supply drawers in survey vehicle); stooping, kneeling (pounding stakes, work over drafting table); crouching and crawling (pounding stakes and pins); reaching and handling (pulling lath off pallet, equipment out of survey vehicles).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Frequently (1\/3 \u2013 2\/3 of workday):<\/strong> carrying 50 lbs. (lath, GPS equipment, briefcase); climbing and balancing (spoils, pits survey, survey vehicles); fingering (run total station, data rec., computer work); depth perception (driving, all phases of surveying); color vision (AutoCAD, color coding maps, flagging, painting).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Continually (2\/3 \u2013 3\/3 of workday):<\/strong> standing and walking (staking and surveying); sitting (drafting, computer, survey vehicles); repetitive motion (computer work, data recording, driving, lath); speaking and hearing (radio communication and office work); seeing (all phases of surveying).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>EEO Statement:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are an equal opportunity employer and we do not discriminate. You must meet at least the specific minimum requirements listed above to be considered a qualified applicant.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Surveyor","post_link":"https:\/\/turnerstaffing.com\/position\/surveyor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">JOB SUMMARY:<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position is responsible for conducting ground and unmanned aerial surveys, processing and managing survey data, and providing AutoCAD drafting support for mining operations. The role installs, maintains, and troubleshoots machine control systems to ensure accurate positioning and operational efficiency. Working closely with engineering, geology, and operations teams, the incumbent provides surveying and technical support essential to mine planning, development, and production activities, while adhering to all safety and regulatory requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Location: Thacker Pass Project in Orovada, NV.<strong>Job Description:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>ESSENTIAL DUTIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform job duties in accordance with MSHA law and regulations, established company safety procedures, and state and federal environmental regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Collect field data using GPS and traditional surveying equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Calculate volumes moved by equipment, including stockpile volumes, truck\/shovel yards, pond capacities, etc.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Establish control and targets for aerial surveys.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Pilot UAS (Unmanned Aircraft System) for aerial surveys and process data to produce topographic maps, calculate quantities, and produce aerial photos.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform CAD applications such as volume computations, haul\/ramp designs, and 3-D modeling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Manage data in spreadsheets as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Calculate monthly pit inventory and ore severed for royalty payments, as well as end-of-month reports and maps.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Construction staking of haul roads, ponds, boundaries, etc.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>OTHER DUTIES:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Create GPS files for equipment in the operations department.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Draft using AutoCAD for mapping, permitting, mine plans, etc.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Install, maintain, and calibrate surveying and machine control equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide various survey support to departments for special projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>KNOWLEDGE, SKILLS, AND ABILITIES<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work independently or cooperatively with co-workers on projects while organizing day-to-day activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of land surveying and engineering principles and practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proficient in technology (AutoCAD, Carlson\/Trimble, Microsoft 365).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Good verbal and written communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with surveying at a surface mining operation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work safely in all weather conditions.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>EDUCATION AND EXPERIENCE:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">A Minimum of two years of post-secondary education in civil engineering technology, surveying, or a related discipline and\/or appropriate surveying and computer experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Additional relevant surveying experience preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">An FAA Part 107 drone license is required or must be obtained within 60 days of hire.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>ANALYSIS OF PHYSICAL DEMANDS OF POSITION:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Intermittently:<\/strong> None<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Occasionally<\/strong> <strong>(0 \u2013 1\/3 of workday):<\/strong> lifting to 60 lbs. (lath, GPS equipment, briefcase); pushing and pulling 30 lbs. (supply drawers in survey vehicle); stooping, kneeling (pounding stakes, work over drafting table); crouching and crawling (pounding stakes and pins); reaching and handling (pulling lath off pallet, equipment out of survey vehicles).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Frequently (1\/3 \u2013 2\/3 of workday):<\/strong> carrying 50 lbs. (lath, GPS equipment, briefcase); climbing and balancing (spoils, pits survey, survey vehicles); fingering (run total station, data rec., computer work); depth perception (driving, all phases of surveying); color vision (AutoCAD, color coding maps, flagging, painting).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Continually (2\/3 \u2013 3\/3 of workday):<\/strong> standing and walking (staking and surveying); sitting (drafting, computer, survey vehicles); repetitive motion (computer work, data recording, driving, lath); speaking and hearing (radio communication and office work); seeing (all phases of surveying).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>EEO Statement:<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are an equal opportunity employer and we do not discriminate. You must meet at least the specific minimum requirements listed above to be considered a qualified applicant.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a5ac278d4251-surveyor","%breezy_id%":"a5ac278d4251","%breezy_friendly_id%":"a5ac278d4251-surveyor","%breezy_created_date%":"2026-09-16T21:55:26.673Z","%breezy_updated_date%":"2026-09-16T21:55:28.975Z","%_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"}},"id":4015,"infowindow_disable":false},{"source":"post","title":"Administrative Assistant","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Administrative Assistant\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a professional, organized, and service-oriented Administrative Assistant to support operations at a mine site near&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/administrative-assistant-2\/\" name=\"Administrative Assistant\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a professional, organized, and service-oriented Administrative Assistant to support operations at a mine site near&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\/administrative-assistant-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a professional, organized, and service-oriented Administrative Assistant to support operations at a mine site near&hellip;","post_content":"<p>Turner Staffing Group is seeking a professional, organized, and service-oriented <strong>Administrative Assistant<\/strong> to support operations at a mine site near <strong>Elko, Nevada<\/strong>. This is a <strong>full-time, project-based assignment<\/strong> supporting site leadership and the project team. The successful candidate will provide administrative, logistical, and office support while helping maintain an organized, efficient, and welcoming work environment.<\/p><p>The ideal candidate is proactive, detail-oriented, and comfortable working in a fast-paced mining environment. This role requires excellent communication skills, strong organizational abilities, and a commitment to supporting safe and efficient site operations.<\/p><p><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p><strong><\/strong>","post_title":"Administrative Assistant","post_link":"https:\/\/turnerstaffing.com\/position\/administrative-assistant-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>Turner Staffing Group is seeking a professional, organized, and service-oriented <strong>Administrative Assistant<\/strong> to support operations at a mine site near <strong>Elko, Nevada<\/strong>. This is a <strong>full-time, project-based assignment<\/strong> supporting site leadership and the project team. The successful candidate will provide administrative, logistical, and office support while helping maintain an organized, efficient, and welcoming work environment.<\/p><p>The ideal candidate is proactive, detail-oriented, and comfortable working in a fast-paced mining environment. This role requires excellent communication skills, strong organizational abilities, and a commitment to supporting safe and efficient site operations.<\/p><p><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p><strong><\/strong>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/xpdku1zx5fqpddfz9bew69oejw","%crelate_id%":"xpdku1zx5fqpddfz9bew69oejw","%crelate_created_date%":"2026-07-06T21:36:34.09Z","%crelate_updated_date%":"2026-09-25T19:47:18.45Z","%_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%":"744"}},"id":4012,"infowindow_disable":false},{"source":"post","title":"Senior Project Mining Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Project Mining Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking an experienced Senior Mining\/Project Engineer to support the planning, construction, and transition to operations of a developing&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-project-mining-engineer\/\" name=\"Senior Project Mining Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking an experienced Senior Mining\/Project Engineer to support the planning, construction, and transition to operations of a developing&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\/senior-project-mining-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking an experienced Senior Mining\/Project Engineer to support the planning, construction, and transition to operations of a developing&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are seeking an experienced <strong>Senior Mining\/Project Engineer<\/strong> to support the planning, construction, and transition to operations of a developing surface lithium mine at the Thacker Pass Project in northern Nevada.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This is a long-term opportunity for an experienced engineer who wants to take an active role in the development of a major surface mining operation. The position offers a combination of <strong>mine engineering, project engineering, construction support, and operational planning<\/strong> within a collaborative, safety-focused environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Senior Mining\/Project Engineer will plan and track short-range production throughout construction and into the mine production phase. This position works closely with operations personnel, engineering teams, and on-site contractors to maintain project schedules, monitor construction and production progress, identify variances, and support the safe and efficient development of the operation.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Essential Duties &amp; Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Track mining, production, and construction activities against established plans, schedules, and project objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop and update short-range mine and construction plans to maintain project schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prepare equipment schedules and support the efficient utilization of mining and earthmoving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop ore grade-control plans and schedules to optimize operational efficiency while meeting material-quality requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Plan and track plant waste streams as the operation transitions into production.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with long-term mine planning, annual work plans, and monthly planning updates.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform end-of-period material reconciliations and prepare associated reports.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prepare progress reports, identify variances from established plans, and communicate findings to project and operational stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide engineering and technical support to operations and maintenance teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Design, coordinate, and oversee construction projects involving buildings, concrete structures, water-management facilities, and related mine infrastructure.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate with contractors, operations personnel, and engineering teams to support safe and timely project execution.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support engineering studies, including operating budgets, optimization studies, equipment evaluations, and project planning.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide technical support for environmental engineering initiatives associated with mine permitting and regulatory compliance, including surface and groundwater management, soils handling, waste management, and blasting.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify engineering and project execution challenges and develop practical solutions to maintain safety, quality, schedule, and operational objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform all responsibilities in accordance with MSHA requirements, established safety procedures, and applicable state and federal regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Bachelor of Science degree in <strong>Mining Engineering, Civil Engineering, Geological Engineering, Construction Engineering, Mechanical Engineering<\/strong>, or a related engineering discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>5\u201310 years of engineering experience in a surface mining environment.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated experience with mine engineering, construction, and\/or project execution.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience supporting mine development, major construction projects, or the transition from development into production is highly desirable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of large earthmoving equipment and its application in surface mining operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with short-range mine planning, production tracking, scheduling, and reconciliation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with AutoCAD.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with mine planning and scheduling software such as <strong>Vulcan, Micromine, Alastri, or similar<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with geologic modeling and mine-planning software; Vulcan experience is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of fleet-management-system reporting is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of civil and environmental engineering applications and applicable environmental and mine-safety regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Familiarity with budgeting, cost analysis, and engineering economics is desirable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong analytical, troubleshooting, and problem-solving capabilities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong written and verbal communication skills with the ability to work effectively across engineering, operations, maintenance, and contractor teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proficiency with Microsoft Office applications.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Location &amp; Relocation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position supports the <strong>Thacker Pass Project in Orovada, Nevada<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates should currently reside in or be willing to relocate to <strong>Winnemucca, Nevada<\/strong>. <strong>Relocation assistance is provided.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical &amp; Work Environment Requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position combines office-based engineering and project responsibilities with regular work in an active surface mining and construction environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Occasionally (up to 1\/3 of the workday):<\/strong> Kneeling or crouching during inspections and troubleshooting; pushing or pulling light equipment and sampling devices; reaching above or below shoulder level; riding in heavy equipment; entering and exiting equipment using three-point contact; working at elevations or on elevated platforms; bending and stooping; lifting up to approximately 30\u201340 pounds; carrying PPE, survey equipment, laptops, tools, or sampling gear; climbing stairs, ladders, and equipment access points; and standing during meetings, inspections, and site observations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Frequently (1\/3\u20132\/3 of the workday):<\/strong> Navigating active mining and construction areas; working around mobile equipment; walking across pit floors, waste dumps, slopes, and uneven or rocky terrain; driving light vehicles throughout the mine site, including distances of 10 or more miles per day; and sitting for engineering design, project planning, scheduling, reporting, AutoCAD, mine-planning software, and other computer-based work.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Constantly (2\/3 or more of the workday):<\/strong> Using fine motor skills for computers, engineering software, GPS, and survey equipment; visual observation for hazard recognition and interpretation of plans and screens; hearing radio communications, alarms, and equipment; communicating with operators, supervisors, engineers, and contractors; maintaining depth perception around haul roads, highwalls, and other mine features; and maintaining situational awareness in an MSHA-regulated environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are an equal opportunity employer and do not discriminate on the basis of any status protected by applicable federal, state, or local law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p>","post_title":"Senior Project Mining Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/senior-project-mining-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are seeking an experienced <strong>Senior Mining\/Project Engineer<\/strong> to support the planning, construction, and transition to operations of a developing surface lithium mine at the Thacker Pass Project in northern Nevada.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This is a long-term opportunity for an experienced engineer who wants to take an active role in the development of a major surface mining operation. The position offers a combination of <strong>mine engineering, project engineering, construction support, and operational planning<\/strong> within a collaborative, safety-focused environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Senior Mining\/Project Engineer will plan and track short-range production throughout construction and into the mine production phase. This position works closely with operations personnel, engineering teams, and on-site contractors to maintain project schedules, monitor construction and production progress, identify variances, and support the safe and efficient development of the operation.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Essential Duties &amp; Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Track mining, production, and construction activities against established plans, schedules, and project objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop and update short-range mine and construction plans to maintain project schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prepare equipment schedules and support the efficient utilization of mining and earthmoving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop ore grade-control plans and schedules to optimize operational efficiency while meeting material-quality requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Plan and track plant waste streams as the operation transitions into production.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with long-term mine planning, annual work plans, and monthly planning updates.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform end-of-period material reconciliations and prepare associated reports.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prepare progress reports, identify variances from established plans, and communicate findings to project and operational stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide engineering and technical support to operations and maintenance teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Design, coordinate, and oversee construction projects involving buildings, concrete structures, water-management facilities, and related mine infrastructure.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate with contractors, operations personnel, and engineering teams to support safe and timely project execution.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support engineering studies, including operating budgets, optimization studies, equipment evaluations, and project planning.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide technical support for environmental engineering initiatives associated with mine permitting and regulatory compliance, including surface and groundwater management, soils handling, waste management, and blasting.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify engineering and project execution challenges and develop practical solutions to maintain safety, quality, schedule, and operational objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform all responsibilities in accordance with MSHA requirements, established safety procedures, and applicable state and federal regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Bachelor of Science degree in <strong>Mining Engineering, Civil Engineering, Geological Engineering, Construction Engineering, Mechanical Engineering<\/strong>, or a related engineering discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>5\u201310 years of engineering experience in a surface mining environment.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated experience with mine engineering, construction, and\/or project execution.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience supporting mine development, major construction projects, or the transition from development into production is highly desirable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of large earthmoving equipment and its application in surface mining operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with short-range mine planning, production tracking, scheduling, and reconciliation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with AutoCAD.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with mine planning and scheduling software such as <strong>Vulcan, Micromine, Alastri, or similar<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with geologic modeling and mine-planning software; Vulcan experience is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of fleet-management-system reporting is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of civil and environmental engineering applications and applicable environmental and mine-safety regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Familiarity with budgeting, cost analysis, and engineering economics is desirable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong analytical, troubleshooting, and problem-solving capabilities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong written and verbal communication skills with the ability to work effectively across engineering, operations, maintenance, and contractor teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proficiency with Microsoft Office applications.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Location &amp; Relocation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position supports the <strong>Thacker Pass Project in Orovada, Nevada<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates should currently reside in or be willing to relocate to <strong>Winnemucca, Nevada<\/strong>. <strong>Relocation assistance is provided.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical &amp; Work Environment Requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position combines office-based engineering and project responsibilities with regular work in an active surface mining and construction environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Occasionally (up to 1\/3 of the workday):<\/strong> Kneeling or crouching during inspections and troubleshooting; pushing or pulling light equipment and sampling devices; reaching above or below shoulder level; riding in heavy equipment; entering and exiting equipment using three-point contact; working at elevations or on elevated platforms; bending and stooping; lifting up to approximately 30\u201340 pounds; carrying PPE, survey equipment, laptops, tools, or sampling gear; climbing stairs, ladders, and equipment access points; and standing during meetings, inspections, and site observations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Frequently (1\/3\u20132\/3 of the workday):<\/strong> Navigating active mining and construction areas; working around mobile equipment; walking across pit floors, waste dumps, slopes, and uneven or rocky terrain; driving light vehicles throughout the mine site, including distances of 10 or more miles per day; and sitting for engineering design, project planning, scheduling, reporting, AutoCAD, mine-planning software, and other computer-based work.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Constantly (2\/3 or more of the workday):<\/strong> Using fine motor skills for computers, engineering software, GPS, and survey equipment; visual observation for hazard recognition and interpretation of plans and screens; hearing radio communications, alarms, and equipment; communicating with operators, supervisors, engineers, and contractors; maintaining depth perception around haul roads, highwalls, and other mine features; and maintaining situational awareness in an MSHA-regulated environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are an equal opportunity employer and do not discriminate on the basis of any status protected by applicable federal, state, or local law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3ceb7580d96c-senior-project-mining-engineer","%breezy_id%":"3ceb7580d96c","%breezy_friendly_id%":"3ceb7580d96c-senior-project-mining-engineer","%breezy_created_date%":"2026-09-16T19:52:58.680Z","%breezy_updated_date%":"2026-09-16T19:53:00.948Z","%_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%":"738"}},"id":4008,"infowindow_disable":false},{"source":"post","title":"Mine Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a Mining Engineer to support the planning, construction, and transition to operations of a developing surface lithium&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-engineer\/\" name=\"Mine Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a Mining Engineer to support the planning, construction, and transition to operations of a developing surface lithium&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\/mine-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a Mining Engineer to support the planning, construction, and transition to operations of a developing surface lithium&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are seeking a <strong>Mining Engineer<\/strong> to support the planning, construction, and transition to operations of a developing surface lithium mine at the Thacker Pass Project in northern Nevada.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This is a long-term opportunity for an early-career mining engineer looking to gain hands-on experience across <strong>mine planning, production, surveying, construction, and project engineering<\/strong>. The position works closely with operations personnel, engineering teams, and on-site contractors in a collaborative, safety-focused environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Mining Engineer will support short-range planning and production tracking throughout construction and into the mine production phase. The role will also help plan and coordinate survey activities, monitor project progress and operating efficiencies, support daily reporting, and contribute to engineering and construction projects across the operation.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Essential Duties &amp; Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop ore grade-control plans and schedules to help ensure material-quality requirements are achieved.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work closely with operations personnel to develop and update short-range plans that support project and production schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with equipment scheduling and utilization to improve operational efficiency.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Plan and coordinate site surveys to validate material movement and verify that construction projects are completed according to plan.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Track construction, mining, and production activities and assist with daily progress and efficiency reporting.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with engineering studies, including operating budgets, optimization studies, and equipment evaluations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide engineering and technical support to operations and maintenance teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Plan and track plant waste streams as the operation transitions into production.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with the design and oversight of construction projects involving buildings, concrete structures, water-management facilities, and related mine infrastructure.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate with operations personnel, engineers, survey teams, and contractors to support safe and efficient project execution.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide technical support for environmental engineering projects associated with mine permitting and regulatory compliance, including surface and groundwater management, soils handling, waste management, and blasting.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform responsibilities in accordance with MSHA requirements, established safety procedures, and applicable state and federal regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Bachelor of Science degree in <strong>Mining Engineering, Civil Engineering, Geological Engineering, Construction Engineering, Mechanical Engineering<\/strong>, or a related engineering discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>1\u20133 years of mining engineering experience in a surface mining operation.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with construction and\/or project management is desirable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Familiarity with large earthmoving equipment and its application in surface mining environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong computer skills and proficiency with Microsoft Office applications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with AutoCAD.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with geologic modeling and mine-planning software; Vulcan experience is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with mine planning or scheduling software such as Vulcan, Micromine, Alastri, or similar is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Surveying experience is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong analytical and problem-solving skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong written, verbal, and interpersonal communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work effectively with operations personnel, engineers, contractors, and other project stakeholders.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Location &amp; Relocation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position supports the <strong>Thacker Pass Project in Orovada, Nevada<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates should currently reside in or be willing to relocate to <strong>Winnemucca, Nevada<\/strong>. <strong>Relocation assistance is provided.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical &amp; Work Environment Requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position combines office-based engineering responsibilities with regular fieldwork in an active surface mining and construction environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Occasionally (up to 1\/3 of the workday):<\/strong> Kneeling or crouching during inspections and troubleshooting; pushing or pulling light equipment and sampling devices; reaching above or below shoulder level; riding in heavy equipment; entering and exiting equipment using three-point contact; working at elevations or on elevated platforms; bending and stooping; lifting up to approximately 30\u201340 pounds; carrying PPE, survey equipment, laptops, tools, or sampling gear; climbing stairs, ladders, and equipment access points; and standing during meetings, inspections, and site observations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Frequently (1\/3\u20132\/3 of the workday):<\/strong> Navigating active mining and construction areas; working around haul trucks and other mobile equipment; walking across pit floors, waste dumps, slopes, and uneven or rocky terrain; driving light vehicles throughout the mine site, including distances of 10 or more miles per day; and sitting for engineering design, planning, scheduling, reporting, AutoCAD, mine-planning software, and other computer-based work.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Constantly (2\/3 or more of the workday):<\/strong> Using fine motor skills for computers, engineering software, GPS, and survey equipment; visual observation for hazard recognition, surveying, and interpretation of plans and screens; hearing radio communications, alarms, and heavy equipment; communicating with operators, supervisors, engineers, and contractors; maintaining depth perception around haul roads, highwalls, and other mine features; and maintaining situational awareness in an MSHA-regulated environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are an equal opportunity employer and do not discriminate on the basis of any status protected by applicable federal, state, or local law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Mine Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/mine-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are seeking a <strong>Mining Engineer<\/strong> to support the planning, construction, and transition to operations of a developing surface lithium mine at the Thacker Pass Project in northern Nevada.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This is a long-term opportunity for an early-career mining engineer looking to gain hands-on experience across <strong>mine planning, production, surveying, construction, and project engineering<\/strong>. The position works closely with operations personnel, engineering teams, and on-site contractors in a collaborative, safety-focused environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Mining Engineer will support short-range planning and production tracking throughout construction and into the mine production phase. The role will also help plan and coordinate survey activities, monitor project progress and operating efficiencies, support daily reporting, and contribute to engineering and construction projects across the operation.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Essential Duties &amp; Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop ore grade-control plans and schedules to help ensure material-quality requirements are achieved.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work closely with operations personnel to develop and update short-range plans that support project and production schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with equipment scheduling and utilization to improve operational efficiency.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Plan and coordinate site surveys to validate material movement and verify that construction projects are completed according to plan.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Track construction, mining, and production activities and assist with daily progress and efficiency reporting.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with engineering studies, including operating budgets, optimization studies, and equipment evaluations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide engineering and technical support to operations and maintenance teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Plan and track plant waste streams as the operation transitions into production.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with the design and oversight of construction projects involving buildings, concrete structures, water-management facilities, and related mine infrastructure.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate with operations personnel, engineers, survey teams, and contractors to support safe and efficient project execution.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide technical support for environmental engineering projects associated with mine permitting and regulatory compliance, including surface and groundwater management, soils handling, waste management, and blasting.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform responsibilities in accordance with MSHA requirements, established safety procedures, and applicable state and federal regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform other duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Bachelor of Science degree in <strong>Mining Engineering, Civil Engineering, Geological Engineering, Construction Engineering, Mechanical Engineering<\/strong>, or a related engineering discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>1\u20133 years of mining engineering experience in a surface mining operation.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with construction and\/or project management is desirable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Familiarity with large earthmoving equipment and its application in surface mining environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong computer skills and proficiency with Microsoft Office applications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with AutoCAD.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with geologic modeling and mine-planning software; Vulcan experience is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with mine planning or scheduling software such as Vulcan, Micromine, Alastri, or similar is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Surveying experience is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong analytical and problem-solving skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong written, verbal, and interpersonal communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work effectively with operations personnel, engineers, contractors, and other project stakeholders.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Location &amp; Relocation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position supports the <strong>Thacker Pass Project in Orovada, Nevada<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates should currently reside in or be willing to relocate to <strong>Winnemucca, Nevada<\/strong>. <strong>Relocation assistance is provided.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical &amp; Work Environment Requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position combines office-based engineering responsibilities with regular fieldwork in an active surface mining and construction environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Occasionally (up to 1\/3 of the workday):<\/strong> Kneeling or crouching during inspections and troubleshooting; pushing or pulling light equipment and sampling devices; reaching above or below shoulder level; riding in heavy equipment; entering and exiting equipment using three-point contact; working at elevations or on elevated platforms; bending and stooping; lifting up to approximately 30\u201340 pounds; carrying PPE, survey equipment, laptops, tools, or sampling gear; climbing stairs, ladders, and equipment access points; and standing during meetings, inspections, and site observations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Frequently (1\/3\u20132\/3 of the workday):<\/strong> Navigating active mining and construction areas; working around haul trucks and other mobile equipment; walking across pit floors, waste dumps, slopes, and uneven or rocky terrain; driving light vehicles throughout the mine site, including distances of 10 or more miles per day; and sitting for engineering design, planning, scheduling, reporting, AutoCAD, mine-planning software, and other computer-based work.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Constantly (2\/3 or more of the workday):<\/strong> Using fine motor skills for computers, engineering software, GPS, and survey equipment; visual observation for hazard recognition, surveying, and interpretation of plans and screens; hearing radio communications, alarms, and heavy equipment; communicating with operators, supervisors, engineers, and contractors; maintaining depth perception around haul roads, highwalls, and other mine features; and maintaining situational awareness in an MSHA-regulated environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are an equal opportunity employer and do not discriminate on the basis of any status protected by applicable federal, state, or local law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/88b9a7711631-mine-engineer","%breezy_id%":"88b9a7711631","%breezy_friendly_id%":"88b9a7711631-mine-engineer","%breezy_created_date%":"2026-09-16T20:09:00.645Z","%breezy_updated_date%":"2026-09-16T20:09:02.831Z","%_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%":"739"}},"id":4009,"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 Geologist to join a growing technical team supporting the development of the Thacker Pass Lithium Clay&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist-3\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a Geologist to join a growing technical team supporting the development of the Thacker Pass Lithium Clay&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\/geologist-3\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a Geologist to join a growing technical team supporting the development of the Thacker Pass Lithium Clay&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are seeking a <strong>Geologist<\/strong> to join a growing technical team supporting the development of the Thacker Pass Lithium Clay Surface Mine in northern Nevada. The operation is preparing for first ore and transitioning from a greenfield development project into an operating mine, providing a unique opportunity to contribute to the development and long-term operation of a significant lithium mining project.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>We are open to candidates across a range of experience levels\u2014from recent geology graduates to experienced mining geologists.<\/strong> Responsibilities and level of ownership will be aligned with the successful candidate\u2019s experience and technical background.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Geologist will support and, depending on experience, lead aspects of <strong>ore-control drilling, geological interpretation, block modeling, QA\/QC, and production reconciliation<\/strong>. This position will work closely with mining operations, engineering, environmental teams, contractors, and other technical personnel across the site.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">For an early-career geologist, the position offers hands-on exposure and professional development across mine geology and operations. For an experienced geologist, the role provides an opportunity to take ownership of key geological processes and contribute directly to the development and optimization of a growing mining operation.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Essential Duties &amp; Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Collect, analyze, and interpret geological, structural, geochemical, and assay data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Plan, coordinate, and support ore-control drilling programs, with level of ownership based on experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Interpret drilling results and integrate geological and assay information into short-range geological, structural, and block models.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support or lead ore-control activities to help ensure ore is identified and mined efficiently while meeting quality requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop, update, and maintain short-range geological, structural, and assay block models used for mine planning.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform and maintain ore-control and production reconciliation tracking.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Collect, analyze, and interpret geotechnical data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain geological files, QA\/QC records, databases, drilling information, and physical samples.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support and help maintain geological QA\/QC programs to ensure accurate and reliable technical data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Monitor applicable state and federal drilling permit requirements and support the protection of mineral reserves.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate with and provide technical oversight to drilling contractors and other contractors performing geological work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Complete geological and technical studies in support of mine planning and operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Collaborate closely with mine operations, engineering, environmental, and other technical teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide geological guidance and technical support to operations as the project transitions into production.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support environmental stewardship and regulatory compliance initiatives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform responsibilities in accordance with MSHA requirements, applicable state and federal regulations, and established safety procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Promote and maintain a strong safety-first culture.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support additional mining-related projects and perform other duties as assigned.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Travel occasionally as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Bachelor\u2019s degree in Geology or a closely related geoscience discipline required.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidates ranging from recent graduates to experienced mining geologists are encouraged to apply.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">For entry-level candidates, relevant internships, co-ops, field experience, research, exploration, or mining exposure is preferred but not required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">For experienced candidates, previous experience with surface mining, exploration drilling, ore control, geological modeling, or production geology is preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of geology, geochemistry, geological modeling, and\/or hydrology.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of or interest in sedimentary geology and lithium deposits.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong computer and data-management skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proficiency with Microsoft Office applications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with <strong>Maptek Vulcan, Geobank, or similar geological database and modeling software<\/strong> is preferred for experienced candidates and a plus for early-career candidates.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with geological block modeling, ore-control systems, and QA\/QC processes is highly desirable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of fleet-management-system reporting is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong analytical, critical-thinking, and problem-solving skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong written and verbal communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to accurately collect, interpret, organize, and communicate technical information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to collaborate effectively with operations personnel, engineers, environmental professionals, contractors, and other technical stakeholders.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred Qualifications<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Depending on experience level, preferred qualifications may include:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Surface mining or production geology experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Exploration and\/or ore-control drilling experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience developing and maintaining geological, structural, and assay block models.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ore-control planning and production reconciliation experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Geological database management and QA\/QC experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience supervising or providing technical direction to drilling contractors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with lithium, sedimentary, clay-hosted, or similar mineral deposits.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Master\u2019s degree in Geology or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Professional Geologist (PG) designation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualified Person experience or qualifications under applicable SEC S-K 1300 and\/or NI 43-101 requirements.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Location &amp; Relocation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position supports the <strong>Thacker Pass Project in Orovada, Nevada<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates should currently reside in or be willing to relocate to <strong>Winnemucca, Nevada. Relocation assistance is provided.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical &amp; Work Environment Requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position combines office-based geological and technical responsibilities with regular fieldwork in an active surface mining and construction environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Occasionally (up to 1\/3 of the workday):<\/strong> Kneeling or crouching during field inspections and sampling; pushing or pulling light equipment; reaching above or below shoulder level; riding in heavy equipment; entering and exiting equipment using three-point contact; working at elevations or on elevated platforms; bending and stooping; lifting up to approximately 30\u201340 pounds, including samples, core boxes, tools, and field equipment; carrying PPE, survey equipment, laptops, and sampling gear; climbing stairs, ladders, and equipment access points; and standing during meetings and field observations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Frequently (1\/3\u20132\/3 of the workday):<\/strong> Navigating active mining areas and working around mobile equipment; walking across pit floors, waste dumps, slopes, and uneven or rocky terrain; driving light vehicles throughout the mine site, including distances of 10 or more miles per day; and sitting for geological modeling, data analysis, reporting, and other computer-based work.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Constantly (2\/3 or more of the workday):<\/strong> Using fine motor skills for computers, geological software, GPS, and field instruments; visual observation for geological interpretation, hazard recognition, and reading plans or computer screens; hearing radio communications, alarms, and heavy equipment; communicating with operations personnel, supervisors, contractors, and technical teams; maintaining depth perception around haul roads, highwalls, and other mine features; and maintaining situational awareness in an MSHA-regulated environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are an equal opportunity employer and do not discriminate on the basis of any status protected by applicable federal, state, or local law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are seeking a <strong>Geologist<\/strong> to join a growing technical team supporting the development of the Thacker Pass Lithium Clay Surface Mine in northern Nevada. The operation is preparing for first ore and transitioning from a greenfield development project into an operating mine, providing a unique opportunity to contribute to the development and long-term operation of a significant lithium mining project.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>We are open to candidates across a range of experience levels\u2014from recent geology graduates to experienced mining geologists.<\/strong> Responsibilities and level of ownership will be aligned with the successful candidate\u2019s experience and technical background.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Geologist will support and, depending on experience, lead aspects of <strong>ore-control drilling, geological interpretation, block modeling, QA\/QC, and production reconciliation<\/strong>. This position will work closely with mining operations, engineering, environmental teams, contractors, and other technical personnel across the site.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">For an early-career geologist, the position offers hands-on exposure and professional development across mine geology and operations. For an experienced geologist, the role provides an opportunity to take ownership of key geological processes and contribute directly to the development and optimization of a growing mining operation.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Essential Duties &amp; Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Collect, analyze, and interpret geological, structural, geochemical, and assay data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Plan, coordinate, and support ore-control drilling programs, with level of ownership based on experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Interpret drilling results and integrate geological and assay information into short-range geological, structural, and block models.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support or lead ore-control activities to help ensure ore is identified and mined efficiently while meeting quality requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop, update, and maintain short-range geological, structural, and assay block models used for mine planning.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform and maintain ore-control and production reconciliation tracking.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Collect, analyze, and interpret geotechnical data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain geological files, QA\/QC records, databases, drilling information, and physical samples.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support and help maintain geological QA\/QC programs to ensure accurate and reliable technical data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Monitor applicable state and federal drilling permit requirements and support the protection of mineral reserves.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate with and provide technical oversight to drilling contractors and other contractors performing geological work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Complete geological and technical studies in support of mine planning and operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Collaborate closely with mine operations, engineering, environmental, and other technical teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide geological guidance and technical support to operations as the project transitions into production.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support environmental stewardship and regulatory compliance initiatives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform responsibilities in accordance with MSHA requirements, applicable state and federal regulations, and established safety procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Promote and maintain a strong safety-first culture.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support additional mining-related projects and perform other duties as assigned.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Travel occasionally as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Bachelor\u2019s degree in Geology or a closely related geoscience discipline required.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidates ranging from recent graduates to experienced mining geologists are encouraged to apply.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">For entry-level candidates, relevant internships, co-ops, field experience, research, exploration, or mining exposure is preferred but not required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">For experienced candidates, previous experience with surface mining, exploration drilling, ore control, geological modeling, or production geology is preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of geology, geochemistry, geological modeling, and\/or hydrology.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of or interest in sedimentary geology and lithium deposits.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong computer and data-management skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proficiency with Microsoft Office applications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with <strong>Maptek Vulcan, Geobank, or similar geological database and modeling software<\/strong> is preferred for experienced candidates and a plus for early-career candidates.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with geological block modeling, ore-control systems, and QA\/QC processes is highly desirable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of fleet-management-system reporting is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong analytical, critical-thinking, and problem-solving skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong written and verbal communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to accurately collect, interpret, organize, and communicate technical information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to collaborate effectively with operations personnel, engineers, environmental professionals, contractors, and other technical stakeholders.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Qualifications<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Depending on experience level, preferred qualifications may include:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Surface mining or production geology experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Exploration and\/or ore-control drilling experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience developing and maintaining geological, structural, and assay block models.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ore-control planning and production reconciliation experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Geological database management and QA\/QC experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience supervising or providing technical direction to drilling contractors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with lithium, sedimentary, clay-hosted, or similar mineral deposits.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Master\u2019s degree in Geology or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Professional Geologist (PG) designation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualified Person experience or qualifications under applicable SEC S-K 1300 and\/or NI 43-101 requirements.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Location &amp; Relocation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position supports the <strong>Thacker Pass Project in Orovada, Nevada<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates should currently reside in or be willing to relocate to <strong>Winnemucca, Nevada. Relocation assistance is provided.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical &amp; Work Environment Requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position combines office-based geological and technical responsibilities with regular fieldwork in an active surface mining and construction environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Occasionally (up to 1\/3 of the workday):<\/strong> Kneeling or crouching during field inspections and sampling; pushing or pulling light equipment; reaching above or below shoulder level; riding in heavy equipment; entering and exiting equipment using three-point contact; working at elevations or on elevated platforms; bending and stooping; lifting up to approximately 30\u201340 pounds, including samples, core boxes, tools, and field equipment; carrying PPE, survey equipment, laptops, and sampling gear; climbing stairs, ladders, and equipment access points; and standing during meetings and field observations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Frequently (1\/3\u20132\/3 of the workday):<\/strong> Navigating active mining areas and working around mobile equipment; walking across pit floors, waste dumps, slopes, and uneven or rocky terrain; driving light vehicles throughout the mine site, including distances of 10 or more miles per day; and sitting for geological modeling, data analysis, reporting, and other computer-based work.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Constantly (2\/3 or more of the workday):<\/strong> Using fine motor skills for computers, geological software, GPS, and field instruments; visual observation for geological interpretation, hazard recognition, and reading plans or computer screens; hearing radio communications, alarms, and heavy equipment; communicating with operations personnel, supervisors, contractors, and technical teams; maintaining depth perception around haul roads, highwalls, and other mine features; and maintaining situational awareness in an MSHA-regulated environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are an equal opportunity employer and do not discriminate on the basis of any status protected by applicable federal, state, or local law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/0f859fdde543-geologist","%breezy_id%":"0f859fdde543","%breezy_friendly_id%":"0f859fdde543-geologist","%breezy_created_date%":"2026-09-16T20:11:31.740Z","%breezy_updated_date%":"2026-09-16T20:11:34.042Z","%_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%":"740"}},"id":4010,"infowindow_disable":false},{"source":"post","title":"Process Manager &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Process Manager &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Process Manager Job Summary The Process Manager is responsible for ensuring efficient ore processing and leading site operations&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/process-manager-mining\/\" name=\"Process Manager &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Process Manager Job Summary The Process Manager is responsible for ensuring efficient ore processing and leading site operations&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\/process-manager-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Process Manager Job Summary The Process Manager is responsible for ensuring efficient ore processing and leading site operations&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Job Title: Process Manager<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Job Summary<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Process Manager is responsible for ensuring efficient ore processing and leading site operations to achieve production and cost-performance targets. This role provides both leadership and technical guidance to the processing team, ensuring safe operations, hands-on problem solving, and continuous improvement aligned with production plans and organizational standards. Key responsibilities include developing team capability in alignment with company values, as well as overseeing budgeting, production forecasting, planning, staffing, cost control, and overall operational profitability.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Duties &amp; Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Serve as the site subject matter expert in mineral processing and operational best practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain a strong field presence to ensure consistent application of operating systems, procedures, controls, and risk-management practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Lead and manage processing operations to maximize production efficiency, safety performance, and cost effectiveness.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop and deliver daily, weekly, and monthly performance reports aligned with operational goals and budget expectations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify and recommend short- and long-term improvement initiatives to enhance processing efficiency and reduce operating costs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Drive continuous improvement by optimizing processes, systems, and equipment performance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate short- and long-term maintenance planning with production requirements, including scheduled downtime activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Utilize SAP and Microsoft Office tools to support operational reporting, analysis, and data-driven decision-making.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform additional duties as required to support site operations and overall business objectives.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Knowledge, Skills &amp; Experience<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><em>Education \/ Certifications<\/em><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Bachelor's degree in Mineral Processing, Metallurgy, Chemical Engineering, or a related engineering discipline strongly preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equivalent combinations of education and demonstrated relevant experience may be considered.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><em>Minimum Experience<\/em><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Minimum of 10 years of experience in the mining or precious metals processing industry.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong knowledge and hands-on experience in heap-leach gold processing, including oversight of:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Leach pads<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Carbon-in-Column (CIC) circuits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">ADR (Adsorption, Desorption, Recovery) plant<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Metallurgical and assay laboratories<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Refinery operations and gold recoveries<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proven experience in production forecasting and process modeling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated success in process optimization and continuous improvement initiatives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong financial and budget-management capabilities, including cost control and production optimization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proven ability to lead safe operations within a heap-leach processing facility.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><em>Skills \/ Knowledge<\/em><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Intermediate computer proficiency, including Microsoft Office and Outlook.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with SAP.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid U.S. driver's license.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to speak, read, write, and comprehend English.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Excellent communication and interpersonal skills with the ability to clearly present technical and operational information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High level of accountability, integrity, and commitment to operational excellence.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In-depth knowledge of mining safety, health, and environmental regulations, with a strong commitment to maintaining a robust safety culture.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Familiarity with crushing and agglomeration preferred but not required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The annual pay range for this position starts at $155,000.00\u2013$206,000.00 based on experience.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Benefits Provided:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Career Advancement Opportunities: Unlock potential for growth and progression with a top mining company<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Competitive Compensation: Attractive pay coupled with bonus incentives<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">401(k) Retirement Plan: Benefit from a company-matched program designed to support your long-term financial security<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comprehensive Insurance Coverage: Access extensive medical, dental, and vision plans for your health and well-being<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Paid Time Off: Maintain a healthy work-life balance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We thank all candidates for their applications, however, only those selected for an interview will be contacted.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">EOE: All qualified applicants will receive consideration for employment without regard to race, color, religion, sex, sexual orientation, gender identity, national origin, disability, or status as a protected veteran.<\/p><h1 style=\"line-height:1.5;margin:0px\"><br><\/h1>","post_title":"Process Manager &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/process-manager-mining\/","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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Job Title: Process Manager<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Job Summary<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Process Manager is responsible for ensuring efficient ore processing and leading site operations to achieve production and cost-performance targets. This role provides both leadership and technical guidance to the processing team, ensuring safe operations, hands-on problem solving, and continuous improvement aligned with production plans and organizational standards. Key responsibilities include developing team capability in alignment with company values, as well as overseeing budgeting, production forecasting, planning, staffing, cost control, and overall operational profitability.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Duties &amp; Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Serve as the site subject matter expert in mineral processing and operational best practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain a strong field presence to ensure consistent application of operating systems, procedures, controls, and risk-management practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Lead and manage processing operations to maximize production efficiency, safety performance, and cost effectiveness.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop and deliver daily, weekly, and monthly performance reports aligned with operational goals and budget expectations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify and recommend short- and long-term improvement initiatives to enhance processing efficiency and reduce operating costs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Drive continuous improvement by optimizing processes, systems, and equipment performance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate short- and long-term maintenance planning with production requirements, including scheduled downtime activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Utilize SAP and Microsoft Office tools to support operational reporting, analysis, and data-driven decision-making.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform additional duties as required to support site operations and overall business objectives.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Knowledge, Skills &amp; Experience<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><em>Education \/ Certifications<\/em><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Bachelor's degree in Mineral Processing, Metallurgy, Chemical Engineering, or a related engineering discipline strongly preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equivalent combinations of education and demonstrated relevant experience may be considered.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><em>Minimum Experience<\/em><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Minimum of 10 years of experience in the mining or precious metals processing industry.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong knowledge and hands-on experience in heap-leach gold processing, including oversight of:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Leach pads<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Carbon-in-Column (CIC) circuits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">ADR (Adsorption, Desorption, Recovery) plant<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Metallurgical and assay laboratories<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Refinery operations and gold recoveries<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proven experience in production forecasting and process modeling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated success in process optimization and continuous improvement initiatives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong financial and budget-management capabilities, including cost control and production optimization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proven ability to lead safe operations within a heap-leach processing facility.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><em>Skills \/ Knowledge<\/em><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Intermediate computer proficiency, including Microsoft Office and Outlook.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with SAP.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid U.S. driver's license.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to speak, read, write, and comprehend English.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Excellent communication and interpersonal skills with the ability to clearly present technical and operational information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High level of accountability, integrity, and commitment to operational excellence.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In-depth knowledge of mining safety, health, and environmental regulations, with a strong commitment to maintaining a robust safety culture.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Familiarity with crushing and agglomeration preferred but not required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The annual pay range for this position starts at $155,000.00\u2013$206,000.00 based on experience.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Benefits Provided:<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Career Advancement Opportunities: Unlock potential for growth and progression with a top mining company<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Competitive Compensation: Attractive pay coupled with bonus incentives<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">401(k) Retirement Plan: Benefit from a company-matched program designed to support your long-term financial security<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comprehensive Insurance Coverage: Access extensive medical, dental, and vision plans for your health and well-being<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Paid Time Off: Maintain a healthy work-life balance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We thank all candidates for their applications, however, only those selected for an interview will be contacted.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">EOE: All qualified applicants will receive consideration for employment without regard to race, color, religion, sex, sexual orientation, gender identity, national origin, disability, or status as a protected veteran.<\/p><h1 style=\"line-height:1.5;margin:0px;\"><br><\/h1>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/00a93d49c927-process-manager-mining","%breezy_id%":"00a93d49c927","%breezy_friendly_id%":"00a93d49c927-process-manager-mining","%breezy_created_date%":"2026-09-10T15:59:52.426Z","%breezy_updated_date%":"2026-09-10T19:02:56.477Z","%_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","%rank_math_analytic_object_id%":"733"}},"id":4003,"infowindow_disable":false},{"source":"post","title":"Fuel Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Fuel Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Fuel Truck Operator Location: Martinsburg, WV Job Type: Full-Time Position Overview Turner Staffing Group seeking an experienced Fuel Truck Operator&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-truck-driver\/\" name=\"Fuel Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Fuel Truck Operator Location: Martinsburg, WV Job Type: Full-Time Position Overview Turner Staffing Group seeking an experienced Fuel Truck Operator&hellip;","address":"Martinsburg, WV, USA","location":{"lat":"39.4562099","city":"Martinsburg","state":"WV","country":"United States","lng":"-77.9638869","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/fuel-truck-driver\/","zoom":19,"extra_fields":{"post_excerpt":"Fuel Truck Operator Location: Martinsburg, WV Job Type: Full-Time Position Overview Turner Staffing Group seeking an experienced Fuel Truck Operator&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Fuel Truck Operator<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Martinsburg, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Job Type:<\/strong> Full-Time<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Position Overview<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span style=\"font-family:Arial;font-size:16px\">Turner Staffing Group<\/span> seeking an experienced <strong>Fuel Truck Operator<\/strong> to support our active construction operations. This position is responsible for safely fueling and servicing heavy equipment, maintaining accurate fuel and fluid records, performing routine preventive maintenance, and supporting multiple active job sites.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The ideal candidate is dependable, safety-focused, comfortable working independently, and experienced with fueling and servicing heavy construction equipment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Plan and operate daily fueling routes across active job sites to ensure equipment is fueled before or between shifts whenever possible.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safely fuel heavy equipment, support vehicles, and on-site fuel storage while preventing spills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Handle, transport, and dispense diesel fuel, DEF, lubricants, and other fluids in accordance with company procedures and applicable regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain spill prevention equipment and spill kits and immediately contain and report any fuel or fluid release.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support site SPCC requirements and environmental compliance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform routine preventive maintenance and field service, including oil, filters, grease, coolant, DEF, and fluid checks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Track fuel and fluid consumption by machine and provide accurate usage reports to the operations team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify and report developing equipment issues discovered during fueling or servicing before they lead to breakdowns.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Complete and document DOT pre-trip and post-trip inspections and remove unsafe vehicles from service.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Monitor fuel inventory and coordinate bulk fuel deliveries with the operations team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safely operate around active construction sites, including soft ground, open excavations, ground personnel, and moving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain compliance with OSHA, DOT, and company safety requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Haul materials, parts, and equipment between job sites as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Keep vehicles, equipment, and job sites clean, safe, and orderly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain fuel tanks within their rated capacities and immediately report any tank changes, additions, or replacements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in occasional night work as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain a valid driver's license and meet company motor vehicle requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comply with all required driver reporting obligations regarding license status, traffic violations, and at-fault accidents.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in at least one continuing education or safety training course each year.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver's license.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Insurable motor vehicle record (MVR).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>2+ years of experience fueling and servicing heavy equipment<\/strong> or comparable fuel delivery experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Fuel handling and spill response training, or the ability to complete required training before operating independently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Working knowledge of DOT pre-trip and post-trip inspection requirements and load securement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">OSHA 10-Hour Construction certification, or the ability to obtain it within 60 days of hire.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work independently across multiple job sites with minimal supervision.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong attention to detail and ability to maintain accurate fuel, maintenance, and inspection records.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work safely around heavy equipment and active construction operations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Note:<\/strong> The fuel trucks used for this position are configured with multiple separate tanks, each individually shut off and each below the 119-gallon bulk-packaging threshold. Therefore, <strong>HazMat (H) and Tanker (N) endorsements are not required<\/strong> for this position.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous experience operating a construction fuel and lube truck.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preventive maintenance or field mechanic experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Familiarity with SPCC plans and job-site environmental compliance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience fueling and servicing heavy construction equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Cross-training or experience operating loaders, skid steers, or other support equipment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What We're Looking For<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We're looking for someone who takes pride in keeping equipment productive and job sites running safely. The successful candidate will be dependable, organized, safety-conscious, and capable of identifying equipment or maintenance issues before they become costly problems.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">If you have experience fueling and servicing heavy equipment and are looking for an important role supporting active construction operations, we'd like to hear from you.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Fuel Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-truck-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Martinsburg","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Martinsburg, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Fuel Truck Operator<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Martinsburg, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Job Type:<\/strong> Full-Time<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Position Overview<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);\">Turner Staffing Group<\/span> seeking an experienced <strong>Fuel Truck Operator<\/strong> to support our active construction operations. This position is responsible for safely fueling and servicing heavy equipment, maintaining accurate fuel and fluid records, performing routine preventive maintenance, and supporting multiple active job sites.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The ideal candidate is dependable, safety-focused, comfortable working independently, and experienced with fueling and servicing heavy construction equipment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Plan and operate daily fueling routes across active job sites to ensure equipment is fueled before or between shifts whenever possible.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safely fuel heavy equipment, support vehicles, and on-site fuel storage while preventing spills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Handle, transport, and dispense diesel fuel, DEF, lubricants, and other fluids in accordance with company procedures and applicable regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain spill prevention equipment and spill kits and immediately contain and report any fuel or fluid release.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support site SPCC requirements and environmental compliance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform routine preventive maintenance and field service, including oil, filters, grease, coolant, DEF, and fluid checks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Track fuel and fluid consumption by machine and provide accurate usage reports to the operations team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify and report developing equipment issues discovered during fueling or servicing before they lead to breakdowns.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Complete and document DOT pre-trip and post-trip inspections and remove unsafe vehicles from service.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Monitor fuel inventory and coordinate bulk fuel deliveries with the operations team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safely operate around active construction sites, including soft ground, open excavations, ground personnel, and moving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain compliance with OSHA, DOT, and company safety requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Haul materials, parts, and equipment between job sites as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Keep vehicles, equipment, and job sites clean, safe, and orderly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain fuel tanks within their rated capacities and immediately report any tank changes, additions, or replacements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in occasional night work as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain a valid driver's license and meet company motor vehicle requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comply with all required driver reporting obligations regarding license status, traffic violations, and at-fault accidents.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in at least one continuing education or safety training course each year.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver's license.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Insurable motor vehicle record (MVR).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>2+ years of experience fueling and servicing heavy equipment<\/strong> or comparable fuel delivery experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Fuel handling and spill response training, or the ability to complete required training before operating independently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Working knowledge of DOT pre-trip and post-trip inspection requirements and load securement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">OSHA 10-Hour Construction certification, or the ability to obtain it within 60 days of hire.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work independently across multiple job sites with minimal supervision.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong attention to detail and ability to maintain accurate fuel, maintenance, and inspection records.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work safely around heavy equipment and active construction operations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Note:<\/strong> The fuel trucks used for this position are configured with multiple separate tanks, each individually shut off and each below the 119-gallon bulk-packaging threshold. Therefore, <strong>HazMat (H) and Tanker (N) endorsements are not required<\/strong> for this position.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous experience operating a construction fuel and lube truck.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preventive maintenance or field mechanic experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Familiarity with SPCC plans and job-site environmental compliance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience fueling and servicing heavy construction equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Cross-training or experience operating loaders, skid steers, or other support equipment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What We're Looking For<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We're looking for someone who takes pride in keeping equipment productive and job sites running safely. The successful candidate will be dependable, organized, safety-conscious, and capable of identifying equipment or maintenance issues before they become costly problems.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">If you have experience fueling and servicing heavy equipment and are looking for an important role supporting active construction operations, we'd like to hear from you.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ffbd5b0c007a-fuel-truck-driver","%breezy_id%":"ffbd5b0c007a","%breezy_friendly_id%":"ffbd5b0c007a-fuel-truck-driver","%breezy_created_date%":"2026-09-10T20:19:55.686Z","%breezy_updated_date%":"2026-09-10T20:19:57.676Z","%_wpgmp_location_city%":"Martinsburg","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Martinsburg, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.4562099","%_wpgmp_metabox_longitude%":"-77.9638869","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"734"}},"id":4004,"infowindow_disable":false},{"source":"post","title":"Talent Acquisition Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Talent Acquisition Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Talent Acquisition Specialist DESCRIPTION: Contract Role Responsibilities \uf0b7 Review applications to ensure a candidate\u2019s background, experience and\/or education align with&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/talent-acquisition-specialist-2\/\" name=\"Talent Acquisition Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Talent Acquisition Specialist DESCRIPTION: Contract Role Responsibilities \uf0b7 Review applications to ensure a candidate\u2019s background, experience and\/or education align with&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\/talent-acquisition-specialist-2\/","zoom":19,"extra_fields":{"post_excerpt":"Talent Acquisition Specialist DESCRIPTION: Contract Role Responsibilities \uf0b7 Review applications to ensure a candidate\u2019s background, experience and\/or education align with&hellip;","post_content":"<h1 style=\"line-height:1.5;margin:0px\">Talent Acquisition Specialist<\/h1><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span style=\"font-family:Arial;font-size:16px\">DESCRIPTION:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>Contract Role Responsibilities<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Review applications to ensure a candidate\u2019s background, experience and\/or<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>education align with the minimum qualifications of the role. Conduct additional<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>screening as applicable, initiate background checks, prepare pay models,<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>generate, and extend offers<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Assessment of candidates will be conducted via phone screening, formal resume<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>submittals from job postings<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Engage with hiring managers to ensure pipeline candidates align with<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>qualifications and needs of the department and its opening(s)<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>Scope of Work Expectation:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 20+ active postings across multiple site locations<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 30+ vacancies (Reqs) without assigned\/identified candidates<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 15+ Different position titles \/ 15+ Different hiring managers<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 15 + Different HR Generalists<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>QUALIFICATIONS:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>&nbsp;Requirements:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 High School diploma or GED and six (6) years of Talent Acquisition\/Human<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>Resources-related experience; OR<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Bachelor\u2019s degree and three (3) years of Talent Acquisition \/Human Resources-<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>related experience<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Employment law principles as they apply to recruiting\/hiring practices<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Ability to pivot and support thirty (30) multi-discipline vacancies, and engage with<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>varying hiring managers and HR staff members<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Knowledge of common recruitment processes, procedures, and sourcing<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>techniques<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>Preferred Qualifications:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Full-cycle recruitment \/ agency recruiting experience. Multiple discipline<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>experience: Skilled Trades and\/or Engineering and\/or Professional recruitment<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>&nbsp;Additional Details:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Candidate needs to be highly organized and attentive to details<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Proficient with technology, business and applicant tracking systems<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Must be able to multi-task, reprioritize based on urgency of business needs and<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>work well in a deadline driven environment<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Strong interpersonal skills<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>\uf0b7 Mining or energy\/oil\/gas background is a plus!<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Talent Acquisition Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/talent-acquisition-specialist-2\/","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%":"<h1 style=\"line-height:1.5;margin:0px;\">Talent Acquisition Specialist<\/h1><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);\">DESCRIPTION:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">Contract Role Responsibilities<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Review applications to ensure a candidate\u2019s background, experience and\/or<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">education align with the minimum qualifications of the role. Conduct additional<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">screening as applicable, initiate background checks, prepare pay models,<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">generate, and extend offers<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Assessment of candidates will be conducted via phone screening, formal resume<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">submittals from job postings<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Engage with hiring managers to ensure pipeline candidates align with<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">qualifications and needs of the department and its opening(s)<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">Scope of Work Expectation:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 20+ active postings across multiple site locations<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 30+ vacancies (Reqs) without assigned\/identified candidates<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 15+ Different position titles \/ 15+ Different hiring managers<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 15 + Different HR Generalists<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">QUALIFICATIONS:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">&nbsp;Requirements:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 High School diploma or GED and six (6) years of Talent Acquisition\/Human<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">Resources-related experience; OR<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Bachelor\u2019s degree and three (3) years of Talent Acquisition \/Human Resources-<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">related experience<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Employment law principles as they apply to recruiting\/hiring practices<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Ability to pivot and support thirty (30) multi-discipline vacancies, and engage with<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">varying hiring managers and HR staff members<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Knowledge of common recruitment processes, procedures, and sourcing<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">techniques<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">Preferred Qualifications:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Full-cycle recruitment \/ agency recruiting experience. Multiple discipline<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">experience: Skilled Trades and\/or Engineering and\/or Professional recruitment<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">&nbsp;Additional Details:<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Candidate needs to be highly organized and attentive to details<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Proficient with technology, business and applicant tracking systems<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Must be able to multi-task, reprioritize based on urgency of business needs and<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">work well in a deadline driven environment<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Strong interpersonal skills<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">\uf0b7 Mining or energy\/oil\/gas background is a plus!<\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ce78beb64e3f-talent-acquisition-specialist","%breezy_id%":"ce78beb64e3f","%breezy_friendly_id%":"ce78beb64e3f-talent-acquisition-specialist","%breezy_created_date%":"2026-09-15T16:41:42.450Z","%breezy_updated_date%":"2026-09-15T16:41:44.449Z","%_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","%rank_math_analytic_object_id%":"736"}},"id":4006,"infowindow_disable":false},{"source":"post","title":"Senior Environmental Engineer &#8211; Air &amp; Waste","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Environmental Engineer &#8211; Air &amp; Waste\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Jerritt Canyon The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the property occurred&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-environmental-engineer-air-waste\/\" name=\"Senior Environmental Engineer &#8211; Air &amp; Waste\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Jerritt Canyon The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the property occurred&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\/senior-environmental-engineer-air-waste\/","zoom":19,"extra_fields":{"post_excerpt":"About Jerritt Canyon The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the property occurred&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>About Jerritt Canyon<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">property occurred in 1981. The Jerritt Canyon property contains 30,821 hectares of mining<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">claims located in the mining-friendly state of Nevada. First Majestic acquired the Jerritt Canyon<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Gold Mine from Sprott Mining Inc. on April 30, 2021. In May 2023, operations were suspended<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">to prioritize exploration and technical studies. Jerritt Canyon is now entering a new phase of<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">evaluation and planning, requiring substantial technical support to advance the work necessary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">for a potential future restart of operations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>The Opportunity<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Sr. Environmental Engineer \u2013 Air &amp;amp; Waste is responsible for leading air quality and waste<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">management programs at Jerritt Canyon. This role provides technical expertise and oversight to<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">ensure compliance with applicable regulations while supporting site operations and future<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">planning efforts.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position works closely with Environmental, Operations, Maintenance, and external<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">stakeholders to manage air permitting, emissions compliance, and waste programs across the<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">site. The role plays a key part in identifying compliance risks, supporting permitting strategies,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">and driving practical, field-based solutions that align with site needs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Responsibilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Lead site air quality and waste management programs to ensure compliance with<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">regulatory and company requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Maintain compliance with all applicable air permits, including tracking requirements,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">monitoring, recordkeeping, and reporting<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Support and lead air permitting efforts, including permit modifications, renewals, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">new applications<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Develop and manage emissions inventories, calculations, and supporting documentation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Conduct or oversee visible emissions observations (VEOs), inspections, and compliance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">evaluations<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Identify air compliance risks and work with Operations to implement practical mitigation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">strategies<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Lead hazardous and non-hazardous waste management programs, including<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">characterization, storage, and disposal<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Ensure compliance with RCRA and other applicable waste regulations, including<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">inspections and reporting<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>JOB DESCRIPTION<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Coordinate waste shipments and manage vendor relationships for disposal and recycling<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Support investigations and reporting for air and waste-related deviations or incidents<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Interface with regulatory agencies and support site inspections, audits, and information<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">requests<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Manage consultants and contractors supporting air and waste programs<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Develop and improve procedures, tracking tools, and compliance systems<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Provide mentorship and technical guidance to junior staff and technicians<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The above responsibilities are representative and may not include all assigned duties.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Education and Experience<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Bachelor\u2019s degree in Environmental Science, Environmental Engineering, Chemical<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Engineering, Civil Engineering, or a related field (required), or equivalent combination of<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">education and relevant experience<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 5+ years of experience in environmental compliance, air quality, waste management, or<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">related roles<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Experience in mining, manufacturing, or other heavy industrial environments preferred<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Working knowledge of air quality regulations (e.g., permitting, emissions calculations,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">compliance reporting) and\/or hazardous waste regulations (e.g., RCRA)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Experience supporting air permitting, emissions inventories, or compliance reporting<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">preferred<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Experience managing hazardous and\/or industrial waste programs, including storage,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">characterization, and disposal<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Familiarity with environmental data management, reporting systems, and compliance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">tracking tools<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Strong organizational, problem-solving, and communication skills<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Ability to manage multiple priorities and work independently while supporting cross-<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">functional teams<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Proficiency in Microsoft Office applications; experience with emissions tracking or<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">compliance systems is a plus<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Demonstrated commitment to safety, environmental compliance, and continuous<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">improvement<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Equal Employment Opportunity<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Company is an equal employment opportunity employer committed to providing<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">employment opportunities to employees and applicants in accordance with all<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">applicable laws.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Senior Environmental Engineer &#8211; Air &amp; Waste","post_link":"https:\/\/turnerstaffing.com\/position\/senior-environmental-engineer-air-waste\/","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=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>About Jerritt Canyon<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">property occurred in 1981. The Jerritt Canyon property contains 30,821 hectares of mining<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">claims located in the mining-friendly state of Nevada. First Majestic acquired the Jerritt Canyon<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Gold Mine from Sprott Mining Inc. on April 30, 2021. In May 2023, operations were suspended<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">to prioritize exploration and technical studies. Jerritt Canyon is now entering a new phase of<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">evaluation and planning, requiring substantial technical support to advance the work necessary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">for a potential future restart of operations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>The Opportunity<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Sr. Environmental Engineer \u2013 Air &amp;amp; Waste is responsible for leading air quality and waste<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">management programs at Jerritt Canyon. This role provides technical expertise and oversight to<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">ensure compliance with applicable regulations while supporting site operations and future<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">planning efforts.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position works closely with Environmental, Operations, Maintenance, and external<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">stakeholders to manage air permitting, emissions compliance, and waste programs across the<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">site. The role plays a key part in identifying compliance risks, supporting permitting strategies,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">and driving practical, field-based solutions that align with site needs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Responsibilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Lead site air quality and waste management programs to ensure compliance with<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">regulatory and company requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Maintain compliance with all applicable air permits, including tracking requirements,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">monitoring, recordkeeping, and reporting<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Support and lead air permitting efforts, including permit modifications, renewals, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">new applications<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Develop and manage emissions inventories, calculations, and supporting documentation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Conduct or oversee visible emissions observations (VEOs), inspections, and compliance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">evaluations<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Identify air compliance risks and work with Operations to implement practical mitigation<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">strategies<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Lead hazardous and non-hazardous waste management programs, including<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">characterization, storage, and disposal<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Ensure compliance with RCRA and other applicable waste regulations, including<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">inspections and reporting<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>JOB DESCRIPTION<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Coordinate waste shipments and manage vendor relationships for disposal and recycling<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Support investigations and reporting for air and waste-related deviations or incidents<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Interface with regulatory agencies and support site inspections, audits, and information<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">requests<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Manage consultants and contractors supporting air and waste programs<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Develop and improve procedures, tracking tools, and compliance systems<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Provide mentorship and technical guidance to junior staff and technicians<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The above responsibilities are representative and may not include all assigned duties.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Education and Experience<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Bachelor\u2019s degree in Environmental Science, Environmental Engineering, Chemical<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Engineering, Civil Engineering, or a related field (required), or equivalent combination of<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">education and relevant experience<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 5+ years of experience in environmental compliance, air quality, waste management, or<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">related roles<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Experience in mining, manufacturing, or other heavy industrial environments preferred<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Working knowledge of air quality regulations (e.g., permitting, emissions calculations,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">compliance reporting) and\/or hazardous waste regulations (e.g., RCRA)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Experience supporting air permitting, emissions inventories, or compliance reporting<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">preferred<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Experience managing hazardous and\/or industrial waste programs, including storage,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">characterization, and disposal<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Familiarity with environmental data management, reporting systems, and compliance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">tracking tools<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Strong organizational, problem-solving, and communication skills<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Ability to manage multiple priorities and work independently while supporting cross-<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">functional teams<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Proficiency in Microsoft Office applications; experience with emissions tracking or<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">compliance systems is a plus<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Demonstrated commitment to safety, environmental compliance, and continuous<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">improvement<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Equal Employment Opportunity<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Company is an equal employment opportunity employer committed to providing<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">employment opportunities to employees and applicants in accordance with all<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">applicable laws.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/928bdd307036-senior-environmental-engineer-air-waste","%breezy_id%":"928bdd307036","%breezy_friendly_id%":"928bdd307036-senior-environmental-engineer-air-waste","%breezy_created_date%":"2026-09-16T16:54:26.095Z","%breezy_updated_date%":"2026-09-16T16:54:28.647Z","%_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%":"737"}},"id":4007,"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    Heavy Equipment Operator \u2013 Loader Operator&nbsp;(CAT 930 &amp; CAT 963) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent)&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-6\/\" name=\"Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Operator \u2013 Loader Operator&nbsp;(CAT 930 &amp; CAT 963) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent)&hellip;","address":"Dulles, VA, USA","location":{"lat":"38.9639112","city":"Dulles","state":"VA","country":"United States","lng":"-77.4496269","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Operator \u2013 Loader Operator&nbsp;(CAT 930 &amp; CAT 963) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent)&hellip;","post_content":"<p><strong>Heavy Equipment Operator \u2013 Loader Operator&nbsp;(CAT 930 &amp; CAT 963)<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p>\n<p><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p>\n<p>Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li><li><strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li><li><strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li><li><strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li><li><strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li><li><strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Dulles","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Dulles, VA","%education%":"","%department%":"TSG","%description%":"<p><strong>Heavy Equipment Operator \u2013 Loader Operator&nbsp;(CAT 930 &amp; CAT 963)<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p>\n<p><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p>\n<p>Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li><li><strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li><li><strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li><li><strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li><li><strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li><li><strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/c84256a85cb0-loader-operator","%breezy_id%":"c84256a85cb0","%breezy_friendly_id%":"c84256a85cb0-loader-operator","%breezy_created_date%":"2026-09-03T20:10:11.190Z","%breezy_updated_date%":"2026-09-03T20:10:45.173Z","%_wpgmp_location_city%":"Dulles","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dulles, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9639112","%_wpgmp_metabox_longitude%":"-77.4496269","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"724"}},"id":3994,"infowindow_disable":false},{"source":"post","title":"Dozer Operator &#8211; Team Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator &#8211; Team Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    GPS Dozer Operator \/ Team Lead Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead-4\/\" name=\"Dozer Operator &#8211; Team Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"GPS Dozer Operator \/ Team Lead Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;","address":"Dulles, VA, USA","location":{"lat":"38.9639112","city":"Dulles","state":"VA","country":"United States","lng":"-77.4496269","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead-4\/","zoom":19,"extra_fields":{"post_excerpt":"GPS Dozer Operator \/ Team Lead Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;","post_content":"<p><strong><u>GPS Dozer Operator \/ Team Lead<\/u><\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT D3, D5\/DK, D6K, D6 XE, D8 Dozers<\/p>\n<p><strong>Reports To:<\/strong> Project Lead<\/p>\n<p><strong>About the Role<\/strong><\/p>\n<p>Are you an experienced dozer operator who knows <strong>Trimble 3D GPS<\/strong> inside and out and thrives in a leadership role? We are seeking a <strong>GPS Dozer Operator \/ Team Lead<\/strong> for a <strong>direct placement position<\/strong> with one of our top civil earthwork clients.<\/p>\n<p>In this role, you\u2019ll lead from the cab and on the ground\u2014running high-production Caterpillar iron, setting up and verifying 3D site models, and directing field crews to complete mass earthwork projects on time and on grade.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Grading &amp; Earthmoving:<\/strong> Operate a full spectrum of CAT dozers (<strong>D3, D6K, D5\/DK, D6 XE Electric Drive, and D8<\/strong>) for mass excavation, fine grading, subgrade preparation, and site setup.<\/li><li><strong>Trimble GPS &amp; Model Verification:<\/strong> Set up Trimble GPS base stations\/rovers, lay out grade stakes, verify digital terrain models against plans, and troubleshoot grade adjustments on the fly.<\/li><li><strong>Crew Leadership &amp; Coordination:<\/strong> Serve as a working Team Lead\u2014directing site personnel, delegating daily tasks, keeping work moving efficiently, and reporting progress to the Project Lead.<\/li><li><strong>Production Tracking &amp; Daily Logs:<\/strong> Complete daily equipment logs and track site production quantities, equipment hours, and delays using <strong>HeavyJob<\/strong> or daily log software.<\/li><li><strong>Auxiliary Equipment Operation:<\/strong> Step into support iron when needed, including skid steers, rollers, and track loaders to keep operations fluid.<\/li><li><strong>Jobsite Safety:<\/strong> Lead daily safety briefings (toolbox talks) and enforce zero-compromise safety protocols around heavy machinery and active earthwork zones.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 4+ years of heavy dozer operation required (preferably focused on civil earthwork and site development).<\/li><li><strong>GPS Expertise:<\/strong> 2+ years of hands-on experience utilizing <strong>Trimble GPS-guided systems<\/strong>, including model verification and grade layout.<\/li><li><strong>Leadership Background:<\/strong> 2+ years of experience leading site crews and managing daily field workflows.<\/li><li><strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required (willingness to obtain OSHA 30 is required).<\/li><li><strong>Reporting &amp; Tech Proficiency:<\/strong> Familiarity with <strong>HeavyJob<\/strong> or electronic daily project logging tools.<\/li><li><strong>Machine Versatility:<\/strong> Competency across small-to-large dozers (CAT D3 to D8) and basic support iron (skid steers\/rollers).<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Dozer Operator &#8211; Team Lead","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Dulles","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Dulles, VA","%education%":"","%department%":"TSG","%description%":"<p><strong><u>GPS Dozer Operator \/ Team Lead<\/u><\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT D3, D5\/DK, D6K, D6 XE, D8 Dozers<\/p>\n<p><strong>Reports To:<\/strong> Project Lead<\/p>\n<p><strong>About the Role<\/strong><\/p>\n<p>Are you an experienced dozer operator who knows <strong>Trimble 3D GPS<\/strong> inside and out and thrives in a leadership role? We are seeking a <strong>GPS Dozer Operator \/ Team Lead<\/strong> for a <strong>direct placement position<\/strong> with one of our top civil earthwork clients.<\/p>\n<p>In this role, you\u2019ll lead from the cab and on the ground\u2014running high-production Caterpillar iron, setting up and verifying 3D site models, and directing field crews to complete mass earthwork projects on time and on grade.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Grading &amp; Earthmoving:<\/strong> Operate a full spectrum of CAT dozers (<strong>D3, D6K, D5\/DK, D6 XE Electric Drive, and D8<\/strong>) for mass excavation, fine grading, subgrade preparation, and site setup.<\/li><li><strong>Trimble GPS &amp; Model Verification:<\/strong> Set up Trimble GPS base stations\/rovers, lay out grade stakes, verify digital terrain models against plans, and troubleshoot grade adjustments on the fly.<\/li><li><strong>Crew Leadership &amp; Coordination:<\/strong> Serve as a working Team Lead\u2014directing site personnel, delegating daily tasks, keeping work moving efficiently, and reporting progress to the Project Lead.<\/li><li><strong>Production Tracking &amp; Daily Logs:<\/strong> Complete daily equipment logs and track site production quantities, equipment hours, and delays using <strong>HeavyJob<\/strong> or daily log software.<\/li><li><strong>Auxiliary Equipment Operation:<\/strong> Step into support iron when needed, including skid steers, rollers, and track loaders to keep operations fluid.<\/li><li><strong>Jobsite Safety:<\/strong> Lead daily safety briefings (toolbox talks) and enforce zero-compromise safety protocols around heavy machinery and active earthwork zones.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 4+ years of heavy dozer operation required (preferably focused on civil earthwork and site development).<\/li><li><strong>GPS Expertise:<\/strong> 2+ years of hands-on experience utilizing <strong>Trimble GPS-guided systems<\/strong>, including model verification and grade layout.<\/li><li><strong>Leadership Background:<\/strong> 2+ years of experience leading site crews and managing daily field workflows.<\/li><li><strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required (willingness to obtain OSHA 30 is required).<\/li><li><strong>Reporting &amp; Tech Proficiency:<\/strong> Familiarity with <strong>HeavyJob<\/strong> or electronic daily project logging tools.<\/li><li><strong>Machine Versatility:<\/strong> Competency across small-to-large dozers (CAT D3 to D8) and basic support iron (skid steers\/rollers).<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/2d1c5a6791a1-dozer-operator-team-lead","%breezy_id%":"2d1c5a6791a1","%breezy_friendly_id%":"2d1c5a6791a1-dozer-operator-team-lead","%breezy_created_date%":"2026-09-03T20:12:28.873Z","%breezy_updated_date%":"2026-09-03T20:13:00.285Z","%_wpgmp_location_city%":"Dulles","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dulles, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9639112","%_wpgmp_metabox_longitude%":"-77.4496269","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"725"}},"id":3995,"infowindow_disable":false},{"source":"post","title":"General Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Build Your Career&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-6\/\" name=\"General Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Build Your Career&hellip;","address":"Frederick, MD, USA","location":{"lat":"39.4142688","city":"Frederick","state":"MD","country":"United States","lng":"-77.4105409","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-6\/","zoom":19,"extra_fields":{"post_excerpt":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Build Your Career&hellip;","post_content":"<p><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p>\n<p><strong>Location:<\/strong> Hagerstown, MD<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n\n<p><strong>Build Your Career in Heavy Construction<\/strong><\/p>\n<p>Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects.<\/p>\n<p>No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p>\n<p><strong>Your Development Path<\/strong><\/p>\n<p>We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p>\n<ol><li><strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li><li><strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li><li><strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li><\/ol>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li><li><strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li><li><strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li><li><strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li><li><strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li><li><strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"General Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Frederick","%location_state_id%":"MD","%location_state_name%":"Maryland","%location_city_state%":"Frederick, MD","%education%":"","%department%":"TSG","%description%":"<p><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p>\n<p><strong>Location:<\/strong> Hagerstown, MD<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n\n<p><strong>Build Your Career in Heavy Construction<\/strong><\/p>\n<p>Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects.<\/p>\n<p>No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p>\n<p><strong>Your Development Path<\/strong><\/p>\n<p>We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p>\n<ol><li><strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li><li><strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li><li><strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li><\/ol>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li><li><strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li><li><strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li><li><strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li><li><strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li><li><strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/6483e453723d-general-construction-laborer","%breezy_id%":"6483e453723d","%breezy_friendly_id%":"6483e453723d-general-construction-laborer","%breezy_created_date%":"2026-09-03T20:30:57.551Z","%breezy_updated_date%":"2026-09-03T20:31:26.244Z","%_wpgmp_location_city%":"Frederick","%_wpgmp_location_state%":"MD","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Frederick, MD, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.4142688","%_wpgmp_metabox_longitude%":"-77.4105409","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"726"}},"id":3996,"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    Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent)&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-7\/\" name=\"Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent)&hellip;","address":"Frederick, MD, USA","location":{"lat":"39.4142688","city":"Frederick","state":"MD","country":"United States","lng":"-77.4105409","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-7\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent)&hellip;","post_content":"<p><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p>\n<p><strong>Location: Hagerstown, MD<\/strong><\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p>\n<p><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p>\n<p>Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Hagerstown, MD<\/strong>.<\/p>\n<p>In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li><li><strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li><li><strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li><li><strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li><li><strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li><li><strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Frederick","%location_state_id%":"MD","%location_state_name%":"Maryland","%location_city_state%":"Frederick, MD","%education%":"","%department%":"TSG","%description%":"<p><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p>\n<p><strong>Location: Hagerstown, MD<\/strong><\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p>\n<p><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p>\n<p>Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Hagerstown, MD<\/strong>.<\/p>\n<p>In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li><li><strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li><li><strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li><li><strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li><li><strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li><li><strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/0fa8d3373cdd-loader-operator","%breezy_id%":"0fa8d3373cdd","%breezy_friendly_id%":"0fa8d3373cdd-loader-operator","%breezy_created_date%":"2026-09-03T20:33:24.745Z","%breezy_updated_date%":"2026-09-03T20:33:55.055Z","%_wpgmp_location_city%":"Frederick","%_wpgmp_location_state%":"MD","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Frederick, MD, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.4142688","%_wpgmp_metabox_longitude%":"-77.4105409","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"727"}},"id":3997,"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    Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Primary Machine: CAT&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-16\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Primary Machine: CAT&hellip;","address":"Frederick, MD, USA","location":{"lat":"39.4142688","city":"Frederick","state":"MD","country":"United States","lng":"-77.4105409","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-16\/","zoom":19,"extra_fields":{"post_excerpt":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Primary Machine: CAT&hellip;","post_content":"<p><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p>\n<p><strong>Location:<\/strong> Hagerstown, MD<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p>\n<p><strong>Reports To:<\/strong> Team Lead<\/p>\n<p><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p>\n<p>Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Hagerstown, MD<\/strong>.<\/p>\n<p>In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li><li><strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li><li><strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li><li><strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li><li><strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li><li><strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-16\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Frederick","%location_state_id%":"MD","%location_state_name%":"Maryland","%location_city_state%":"Frederick, MD","%education%":"","%department%":"TSG","%description%":"<p><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p>\n<p><strong>Location:<\/strong> Hagerstown, MD<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p>\n<p><strong>Reports To:<\/strong> Team Lead<\/p>\n<p><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p>\n<p>Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Hagerstown, MD<\/strong>.<\/p>\n<p>In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li><li><strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li><li><strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li><li><strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li><li><strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li><li><strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/dbf65d4a7d3e-excavator-operator","%breezy_id%":"dbf65d4a7d3e","%breezy_friendly_id%":"dbf65d4a7d3e-excavator-operator","%breezy_created_date%":"2026-09-03T20:37:25.023Z","%breezy_updated_date%":"2026-09-03T20:37:55.452Z","%_wpgmp_location_city%":"Frederick","%_wpgmp_location_state%":"MD","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Frederick, MD, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.4142688","%_wpgmp_metabox_longitude%":"-77.4105409","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"728"}},"id":3998,"infowindow_disable":false},{"source":"post","title":"Pipe Layer &#8211; Team Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Pipe Layer &#8211; Team Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Team Lead Pipe Layer \u2013 Underground Utilities Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe Lasers,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-layer-team-lead-3\/\" name=\"Pipe Layer &#8211; Team Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe Lasers,&hellip;","address":"Frederick, MD, USA","location":{"lat":"39.4142688","city":"Frederick","state":"MD","country":"United States","lng":"-77.4105409","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pipe-layer-team-lead-3\/","zoom":19,"extra_fields":{"post_excerpt":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe Lasers,&hellip;","post_content":"<p><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Hagerstown, MD<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p>\n<p><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p>\n<p>Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Hagerstown, MD<\/strong>.<\/p>\n<p>In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li><li><strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li><li><strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li><li><strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li><li><strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li><li><strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li><li><strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Pipe Layer &#8211; Team Lead","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-layer-team-lead-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Frederick","%location_state_id%":"MD","%location_state_name%":"Maryland","%location_city_state%":"Frederick, MD","%education%":"","%department%":"TSG","%description%":"<p><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Hagerstown, MD<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p>\n<p><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p>\n<p>Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Hagerstown, MD<\/strong>.<\/p>\n<p>In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li><li><strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li><li><strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li><li><strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li><li><strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li><li><strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li><li><strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/8e907492dc7b-pipe-layer-team-lead","%breezy_id%":"8e907492dc7b","%breezy_friendly_id%":"8e907492dc7b-pipe-layer-team-lead","%breezy_created_date%":"2026-09-03T20:40:58.901Z","%breezy_updated_date%":"2026-09-03T20:41:38.286Z","%_wpgmp_location_city%":"Frederick","%_wpgmp_location_state%":"MD","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Frederick, MD, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.4142688","%_wpgmp_metabox_longitude%":"-77.4105409","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"729"}},"id":3999,"infowindow_disable":false},{"source":"post","title":"Dozer Operator &#8211; Team Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator &#8211; Team Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    GPS Dozer Operator \/ Team Lead Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead-3\/\" name=\"Dozer Operator &#8211; Team Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"GPS Dozer Operator \/ Team Lead Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;","address":"Washington, DC, USA","location":{"lat":"38.9072873","city":"Washington","state":"DC","country":"United States","lng":"-77.0369274","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead-3\/","zoom":19,"extra_fields":{"post_excerpt":"GPS Dozer Operator \/ Team Lead Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;","post_content":"<p><strong><u>GPS Dozer Operator \/ Team Lead<\/u><\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT D3, D5\/DK, D6K, D6 XE, D8 Dozers<\/p>\n<p><strong>Reports To:<\/strong> Project Lead<\/p>\n<p><strong>About the Role<\/strong><\/p>\n<p>Are you an experienced dozer operator who knows <strong>Trimble 3D GPS<\/strong> inside and out and thrives in a leadership role? We are seeking a <strong>GPS Dozer Operator \/ Team Lead<\/strong> for a <strong>direct placement position<\/strong> with one of our top civil earthwork clients in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you\u2019ll lead from the cab and on the ground\u2014running high-production Caterpillar iron, setting up and verifying 3D site models, and directing field crews to complete mass earthwork projects on time and on grade.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Grading &amp; Earthmoving:<\/strong> Operate a full spectrum of CAT dozers (<strong>D3, D6K, D5\/DK, D6 XE Electric Drive, and D8<\/strong>) for mass excavation, fine grading, subgrade preparation, and site setup.<\/li><li><strong>Trimble GPS &amp; Model Verification:<\/strong> Set up Trimble GPS base stations\/rovers, lay out grade stakes, verify digital terrain models against plans, and troubleshoot grade adjustments on the fly.<\/li><li><strong>Crew Leadership &amp; Coordination:<\/strong> Serve as a working Team Lead\u2014directing site personnel, delegating daily tasks, keeping work moving efficiently, and reporting progress to the Project Lead.<\/li><li><strong>Production Tracking &amp; Daily Logs:<\/strong> Complete daily equipment logs and track site production quantities, equipment hours, and delays using <strong>HeavyJob<\/strong> or daily log software.<\/li><li><strong>Auxiliary Equipment Operation:<\/strong> Step into support iron when needed, including skid steers, rollers, and track loaders to keep operations fluid.<\/li><li><strong>Jobsite Safety:<\/strong> Lead daily safety briefings (toolbox talks) and enforce zero-compromise safety protocols around heavy machinery and active earthwork zones.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 4+ years of heavy dozer operation required (preferably focused on civil earthwork and site development).<\/li><li><strong>GPS Expertise:<\/strong> 2+ years of hands-on experience utilizing <strong>Trimble GPS-guided systems<\/strong>, including model verification and grade layout.<\/li><li><strong>Leadership Background:<\/strong> 2+ years of experience leading site crews and managing daily field workflows.<\/li><li><strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required (willingness to obtain OSHA 30 is required).<\/li><li><strong>Reporting &amp; Tech Proficiency:<\/strong> Familiarity with <strong>HeavyJob<\/strong> or electronic daily project logging tools.<\/li><li><strong>Machine Versatility:<\/strong> Competency across small-to-large dozers (CAT D3 to D8) and basic support iron (skid steers\/rollers).<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Dozer Operator &#8211; Team Lead","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Washington","%location_state_id%":"DC","%location_state_name%":"Dist. of Columbia","%location_city_state%":"Washington, DC","%education%":"","%department%":"TSG","%description%":"<p><strong><u>GPS Dozer Operator \/ Team Lead<\/u><\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT D3, D5\/DK, D6K, D6 XE, D8 Dozers<\/p>\n<p><strong>Reports To:<\/strong> Project Lead<\/p>\n<p><strong>About the Role<\/strong><\/p>\n<p>Are you an experienced dozer operator who knows <strong>Trimble 3D GPS<\/strong> inside and out and thrives in a leadership role? We are seeking a <strong>GPS Dozer Operator \/ Team Lead<\/strong> for a <strong>direct placement position<\/strong> with one of our top civil earthwork clients in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you\u2019ll lead from the cab and on the ground\u2014running high-production Caterpillar iron, setting up and verifying 3D site models, and directing field crews to complete mass earthwork projects on time and on grade.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Grading &amp; Earthmoving:<\/strong> Operate a full spectrum of CAT dozers (<strong>D3, D6K, D5\/DK, D6 XE Electric Drive, and D8<\/strong>) for mass excavation, fine grading, subgrade preparation, and site setup.<\/li><li><strong>Trimble GPS &amp; Model Verification:<\/strong> Set up Trimble GPS base stations\/rovers, lay out grade stakes, verify digital terrain models against plans, and troubleshoot grade adjustments on the fly.<\/li><li><strong>Crew Leadership &amp; Coordination:<\/strong> Serve as a working Team Lead\u2014directing site personnel, delegating daily tasks, keeping work moving efficiently, and reporting progress to the Project Lead.<\/li><li><strong>Production Tracking &amp; Daily Logs:<\/strong> Complete daily equipment logs and track site production quantities, equipment hours, and delays using <strong>HeavyJob<\/strong> or daily log software.<\/li><li><strong>Auxiliary Equipment Operation:<\/strong> Step into support iron when needed, including skid steers, rollers, and track loaders to keep operations fluid.<\/li><li><strong>Jobsite Safety:<\/strong> Lead daily safety briefings (toolbox talks) and enforce zero-compromise safety protocols around heavy machinery and active earthwork zones.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 4+ years of heavy dozer operation required (preferably focused on civil earthwork and site development).<\/li><li><strong>GPS Expertise:<\/strong> 2+ years of hands-on experience utilizing <strong>Trimble GPS-guided systems<\/strong>, including model verification and grade layout.<\/li><li><strong>Leadership Background:<\/strong> 2+ years of experience leading site crews and managing daily field workflows.<\/li><li><strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required (willingness to obtain OSHA 30 is required).<\/li><li><strong>Reporting &amp; Tech Proficiency:<\/strong> Familiarity with <strong>HeavyJob<\/strong> or electronic daily project logging tools.<\/li><li><strong>Machine Versatility:<\/strong> Competency across small-to-large dozers (CAT D3 to D8) and basic support iron (skid steers\/rollers).<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/9acceaaad394-dozer-operator-team-lead","%breezy_id%":"9acceaaad394","%breezy_friendly_id%":"9acceaaad394-dozer-operator-team-lead","%breezy_created_date%":"2026-09-03T18:42:57.524Z","%breezy_updated_date%":"2026-09-03T18:43:42.529Z","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"DC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Washington, DC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9072873","%_wpgmp_metabox_longitude%":"-77.0369274","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"716"}},"id":3986,"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    Excavator Operator &#8211; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT 320 \u2013&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-13\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Excavator Operator &#8211; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT 320 \u2013&hellip;","address":"Washington, DC, USA","location":{"lat":"38.9072873","city":"Washington","state":"DC","country":"United States","lng":"-77.0369274","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-13\/","zoom":19,"extra_fields":{"post_excerpt":"Excavator Operator &#8211; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT 320 \u2013&hellip;","post_content":"<p><strong>Excavator Operator - Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 320 \u2013 CAT 336 Excavators<\/p>\n<p><strong>Reports To:<\/strong> Team Lead<\/p>\n<p><strong>About the Role<\/strong><\/p>\n<p>Are you a skilled heavy equipment operator looking for a <strong>permanent, direct-hire opportunity<\/strong> with steady work and modern iron? We are hiring an experienced <strong>Excavator Operator<\/strong> to join our site utility team in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you\u2019ll be a vital part of our underground utility crew, operating heavy production excavators (<strong>CAT 320 to CAT 336<\/strong>) to dig trenches, place pipe, and manage material on site. You will work directly under the guidance of our Team Lead to execute precise, safe, and efficient utility installations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Excavation:<\/strong> Dig trenches to exact grade and depth for underground utility systems (water, sewer, storm, etc.) in dynamic soil conditions.<\/li><li><strong>Trench &amp; Pipe Operations:<\/strong> Lift, move, and position heavy pipe, trench boxes, and utility structures directly into the trench with precision and care.<\/li><li><strong>Controlled Backfill:<\/strong> Place and compact backfill material in controlled lifts to ensure proper structural integrity and meet compaction specifications.<\/li><li><strong>Cross-Equipment Operation:<\/strong> Occasionally step into auxiliary machines, such as <strong>CAT 930 rubber-tired loaders<\/strong> or <strong>CAT 963 track loaders<\/strong>, to assist with site prep, material management, and stock piling.<\/li><li><strong>Daily Maintenance &amp; Logs:<\/strong> Perform standard pre-shift\/post-shift inspections and accurately complete daily equipment logs.<\/li><li><strong>Jobsite Safety:<\/strong> Maintain a strict safety-first mindset around open excavations, existing utility lines, and ground personnel.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 2 years of heavy excavator operation required (<strong>3 to 5+ years preferred<\/strong>).<\/li><li><strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required.<\/li><li><strong>Underground Utility Focus:<\/strong> Direct experience working around underground utilities is required; <strong>pipelaying experience is highly preferred<\/strong>.<\/li><li><strong>Fleet Familiarity:<\/strong> Demonstrated competency operating CAT 320 to 336 class excavators (or equivalent mid-to-heavy machines).<\/li><li><strong>Versatility:<\/strong> Willingness to operate support machinery (CAT 930 loader \/ CAT 963 track loader) when needed.<\/li><li><strong>Reliability &amp; Teamwork:<\/strong> Strong work ethic, reliable attendance, and ability to collaborate effectively with field team members and the Team Lead.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-13\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Washington","%location_state_id%":"DC","%location_state_name%":"Dist. of Columbia","%location_city_state%":"Washington, DC","%education%":"","%department%":"TSG","%description%":"<p><strong>Excavator Operator - Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 320 \u2013 CAT 336 Excavators<\/p>\n<p><strong>Reports To:<\/strong> Team Lead<\/p>\n<p><strong>About the Role<\/strong><\/p>\n<p>Are you a skilled heavy equipment operator looking for a <strong>permanent, direct-hire opportunity<\/strong> with steady work and modern iron? We are hiring an experienced <strong>Excavator Operator<\/strong> to join our site utility team in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you\u2019ll be a vital part of our underground utility crew, operating heavy production excavators (<strong>CAT 320 to CAT 336<\/strong>) to dig trenches, place pipe, and manage material on site. You will work directly under the guidance of our Team Lead to execute precise, safe, and efficient utility installations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Excavation:<\/strong> Dig trenches to exact grade and depth for underground utility systems (water, sewer, storm, etc.) in dynamic soil conditions.<\/li><li><strong>Trench &amp; Pipe Operations:<\/strong> Lift, move, and position heavy pipe, trench boxes, and utility structures directly into the trench with precision and care.<\/li><li><strong>Controlled Backfill:<\/strong> Place and compact backfill material in controlled lifts to ensure proper structural integrity and meet compaction specifications.<\/li><li><strong>Cross-Equipment Operation:<\/strong> Occasionally step into auxiliary machines, such as <strong>CAT 930 rubber-tired loaders<\/strong> or <strong>CAT 963 track loaders<\/strong>, to assist with site prep, material management, and stock piling.<\/li><li><strong>Daily Maintenance &amp; Logs:<\/strong> Perform standard pre-shift\/post-shift inspections and accurately complete daily equipment logs.<\/li><li><strong>Jobsite Safety:<\/strong> Maintain a strict safety-first mindset around open excavations, existing utility lines, and ground personnel.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 2 years of heavy excavator operation required (<strong>3 to 5+ years preferred<\/strong>).<\/li><li><strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required.<\/li><li><strong>Underground Utility Focus:<\/strong> Direct experience working around underground utilities is required; <strong>pipelaying experience is highly preferred<\/strong>.<\/li><li><strong>Fleet Familiarity:<\/strong> Demonstrated competency operating CAT 320 to 336 class excavators (or equivalent mid-to-heavy machines).<\/li><li><strong>Versatility:<\/strong> Willingness to operate support machinery (CAT 930 loader \/ CAT 963 track loader) when needed.<\/li><li><strong>Reliability &amp; Teamwork:<\/strong> Strong work ethic, reliable attendance, and ability to collaborate effectively with field team members and the Team Lead.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/48e2df4bc3b4-excavator-operator","%breezy_id%":"48e2df4bc3b4","%breezy_friendly_id%":"48e2df4bc3b4-excavator-operator","%breezy_created_date%":"2026-09-03T18:47:03.866Z","%breezy_updated_date%":"2026-09-03T18:47:38.817Z","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"DC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Washington, DC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9072873","%_wpgmp_metabox_longitude%":"-77.0369274","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"717"}},"id":3987,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Haul Truck Driver \u2013 Heavy Equipment Operator Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-4\/\" name=\"Haul Truck Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Haul Truck Driver \u2013 Heavy Equipment Operator Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;","address":"Dulles, VA, USA","location":{"lat":"38.9639112","city":"Dulles","state":"VA","country":"United States","lng":"-77.4496269","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"Haul Truck Driver \u2013 Heavy Equipment Operator Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;","post_content":"<p><strong>Haul Truck Driver \u2013 Heavy Equipment Operator<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 730 \/ CAT 740 Articulated Haul Trucks<\/p>\n<p><strong>Take the Wheel of Powerful Machinery in Front Royal!<\/strong><\/p>\n<p>Are you a skilled operator who takes pride in driving heavy iron and keeping civil jobsites moving? We are hiring a dependable, safety-focused <strong>Haul Truck Driver<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>You will primarily pilot <strong>CAT 730 and 740 haul trucks<\/strong> on active underground utility projects, with opportunities to operate secondary support machinery like skid steers and small wheel loaders.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Haul Truck Operations:<\/strong> Safely operate <strong>CAT 730 and 740 articulated haul trucks<\/strong> to haul soil, aggregate, backfill, and rock across underground utility construction sites.<\/li><li><strong>Versatile Equipment Support:<\/strong> Occasionally operate support equipment such as <strong>skid steers and small wheel loaders<\/strong> for site staging, backfilling, and material movement.<\/li><li><strong>Pre\/Post-Trip Inspections:<\/strong> Perform daily pre-trip and post-trip equipment safety checks (fluids, hydraulics, tires, lights) to ensure machine reliability.<\/li><li><strong>Daily Logging:<\/strong> Accurately complete daily logs, maintenance sheets, and material load tallies.<\/li><li><strong>Jobsite Collaboration:<\/strong> Coordinate closely with site superintendents, excavator operators, and pipe crews for efficient site flow and safety.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>2+ years of experience preferred<\/strong> operating articulated haul trucks (CAT 730\/740 or similar civil earthmoving equipment).<\/li><li><strong>Equipment Versatility:<\/strong> Ability or willingness to occasionally jump into skid steers and small wheel loaders when needed.<\/li><li><strong>Certifications:<\/strong> OSHA 10 preferred and a valid drivers license.<\/li><li><strong>Utility Site Knowledge:<\/strong> Familiarity with civil site earthmoving and underground utility construction environments.<\/li><li><strong>Reliability:<\/strong> Strong commitment to daily pre\/post-trip safety checks, daily logging, and punctual attendance.<\/li><\/ul>","post_title":"Haul Truck Operator","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Dulles","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Dulles, VA","%education%":"","%department%":"TSG","%description%":"<p><strong>Haul Truck Driver \u2013 Heavy Equipment Operator<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 730 \/ CAT 740 Articulated Haul Trucks<\/p>\n<p><strong>Take the Wheel of Powerful Machinery in Front Royal!<\/strong><\/p>\n<p>Are you a skilled operator who takes pride in driving heavy iron and keeping civil jobsites moving? We are hiring a dependable, safety-focused <strong>Haul Truck Driver<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>You will primarily pilot <strong>CAT 730 and 740 haul trucks<\/strong> on active underground utility projects, with opportunities to operate secondary support machinery like skid steers and small wheel loaders.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Haul Truck Operations:<\/strong> Safely operate <strong>CAT 730 and 740 articulated haul trucks<\/strong> to haul soil, aggregate, backfill, and rock across underground utility construction sites.<\/li><li><strong>Versatile Equipment Support:<\/strong> Occasionally operate support equipment such as <strong>skid steers and small wheel loaders<\/strong> for site staging, backfilling, and material movement.<\/li><li><strong>Pre\/Post-Trip Inspections:<\/strong> Perform daily pre-trip and post-trip equipment safety checks (fluids, hydraulics, tires, lights) to ensure machine reliability.<\/li><li><strong>Daily Logging:<\/strong> Accurately complete daily logs, maintenance sheets, and material load tallies.<\/li><li><strong>Jobsite Collaboration:<\/strong> Coordinate closely with site superintendents, excavator operators, and pipe crews for efficient site flow and safety.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>2+ years of experience preferred<\/strong> operating articulated haul trucks (CAT 730\/740 or similar civil earthmoving equipment).<\/li><li><strong>Equipment Versatility:<\/strong> Ability or willingness to occasionally jump into skid steers and small wheel loaders when needed.<\/li><li><strong>Certifications:<\/strong> OSHA 10 preferred and a valid drivers license.<\/li><li><strong>Utility Site Knowledge:<\/strong> Familiarity with civil site earthmoving and underground utility construction environments.<\/li><li><strong>Reliability:<\/strong> Strong commitment to daily pre\/post-trip safety checks, daily logging, and punctual attendance.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/fb6fab79d920-haul-truck-operator","%breezy_id%":"fb6fab79d920","%breezy_friendly_id%":"fb6fab79d920-haul-truck-operator","%breezy_created_date%":"2026-09-03T19:38:59.173Z","%breezy_updated_date%":"2026-09-03T19:43:04.882Z","%_wpgmp_location_city%":"Dulles","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dulles, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9639112","%_wpgmp_metabox_longitude%":"-77.4496269","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"718"}},"id":3988,"infowindow_disable":false},{"source":"post","title":"Project Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Lead \u2013 Site Development &amp; Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-lead-5\/\" name=\"Project Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Lead \u2013 Site Development &amp; Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;","address":"Dulles, VA, USA","location":{"lat":"38.9639112","city":"Dulles","state":"VA","country":"United States","lng":"-77.4496269","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-lead-5\/","zoom":19,"extra_fields":{"post_excerpt":"Project Lead \u2013 Site Development &amp; Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;","post_content":"<p><strong>Project Lead \u2013 Site Development &amp; Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Software System:<\/strong> HeavyJob<\/p>\n<p><strong>Drive Projects. Direct Crews. Master the Dirt &amp; Utilities!<\/strong><\/p>\n<p>Are you an experienced civil construction leader who knows how to run a jobsite with precision and accountability? We are hiring a <strong>Project Lead<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this role, you will serve as the operational anchor for site development and underground utility projects\u2014managing budgets, schedules, subcontractors, and municipal inspectors in <strong>HeavyJob<\/strong>, while retaining the hands-on skill to operate heavy equipment when the job demands it.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Multi-Crew Leadership:<\/strong> Schedule, direct, and mentor multiple field crews across site prep, bulk earthmoving, and underground utility installations (storm, sanitary, water).<\/li><li><strong>Budget &amp; Schedule Accountability:<\/strong> Manage daily project costs and schedules, optimize labor and machine utilization, and track production in <strong>HeavyJob<\/strong>.<\/li><li><strong>Subcontractor &amp; Inspector Coordination:<\/strong> Coordinate subcontractor workflows and build working relationships with municipal inspectors to secure project sign-offs.<\/li><li><strong>Hands-On Field Operations:<\/strong> Lead from the front by operating heavy equipment when needed\u2014including excavators, dozers, loaders, haul trucks, and pipelaying equipment.<\/li><li><strong>Safety &amp; Daily Reporting:<\/strong> Enforce OSHA safety standards, track daily logs and job yields, and maintain site compliance.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years<\/strong> in site development and underground utility construction.<\/li><li><strong>Leadership Track Record:<\/strong> <strong>2\u20133 years<\/strong> of experience running complete civil projects and directing multiple crews.<\/li><li><strong>Software &amp; Equipment Skills:<\/strong> Hands-on proficiency using <strong>HeavyJob<\/strong>; practical ability to operate dozers, loaders, excavators, dump trucks, and pipelaying gear.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (<strong>OSHA 30 preferred<\/strong>)&nbsp;and <strong>Trench &amp; Excavation Competent Person Certification<\/strong> (Preferred)<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Project Lead","post_link":"https:\/\/turnerstaffing.com\/position\/project-lead-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Dulles","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Dulles, VA","%education%":"","%department%":"TSG","%description%":"<p><strong>Project Lead \u2013 Site Development &amp; Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Software System:<\/strong> HeavyJob<\/p>\n<p><strong>Drive Projects. Direct Crews. Master the Dirt &amp; Utilities!<\/strong><\/p>\n<p>Are you an experienced civil construction leader who knows how to run a jobsite with precision and accountability? We are hiring a <strong>Project Lead<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this role, you will serve as the operational anchor for site development and underground utility projects\u2014managing budgets, schedules, subcontractors, and municipal inspectors in <strong>HeavyJob<\/strong>, while retaining the hands-on skill to operate heavy equipment when the job demands it.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Multi-Crew Leadership:<\/strong> Schedule, direct, and mentor multiple field crews across site prep, bulk earthmoving, and underground utility installations (storm, sanitary, water).<\/li><li><strong>Budget &amp; Schedule Accountability:<\/strong> Manage daily project costs and schedules, optimize labor and machine utilization, and track production in <strong>HeavyJob<\/strong>.<\/li><li><strong>Subcontractor &amp; Inspector Coordination:<\/strong> Coordinate subcontractor workflows and build working relationships with municipal inspectors to secure project sign-offs.<\/li><li><strong>Hands-On Field Operations:<\/strong> Lead from the front by operating heavy equipment when needed\u2014including excavators, dozers, loaders, haul trucks, and pipelaying equipment.<\/li><li><strong>Safety &amp; Daily Reporting:<\/strong> Enforce OSHA safety standards, track daily logs and job yields, and maintain site compliance.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years<\/strong> in site development and underground utility construction.<\/li><li><strong>Leadership Track Record:<\/strong> <strong>2\u20133 years<\/strong> of experience running complete civil projects and directing multiple crews.<\/li><li><strong>Software &amp; Equipment Skills:<\/strong> Hands-on proficiency using <strong>HeavyJob<\/strong>; practical ability to operate dozers, loaders, excavators, dump trucks, and pipelaying gear.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (<strong>OSHA 30 preferred<\/strong>)&nbsp;and <strong>Trench &amp; Excavation Competent Person Certification<\/strong> (Preferred)<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/bbfca80d45dc-project-lead","%breezy_id%":"bbfca80d45dc","%breezy_friendly_id%":"bbfca80d45dc-project-lead","%breezy_created_date%":"2026-09-03T19:45:05.997Z","%breezy_updated_date%":"2026-09-03T19:45:39.227Z","%_wpgmp_location_city%":"Dulles","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dulles, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9639112","%_wpgmp_metabox_longitude%":"-77.4496269","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"719"}},"id":3989,"infowindow_disable":false},{"source":"post","title":"Pipe Layer &#8211; Team Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Pipe Layer &#8211; Team Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Team Lead Pipe Layer \u2013 Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-layer-team-lead-2\/\" name=\"Pipe Layer &#8211; Team Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;","address":"Dulles, VA, USA","location":{"lat":"38.9639112","city":"Dulles","state":"VA","country":"United States","lng":"-77.4496269","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pipe-layer-team-lead-2\/","zoom":19,"extra_fields":{"post_excerpt":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;","post_content":"<p><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p>\n<p><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p>\n<p>Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li><li><strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li><li><strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li><li><strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li><li><strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li><li><strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li><li><strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li><\/ul>","post_title":"Pipe Layer &#8211; Team Lead","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-layer-team-lead-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Dulles","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Dulles, VA","%education%":"","%department%":"TSG","%description%":"<p><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p>\n<p><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p>\n<p>Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li><li><strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li><li><strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li><li><strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li><li><strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li><li><strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li><li><strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b9d21fffb897-pipe-layer-team-lead","%breezy_id%":"b9d21fffb897","%breezy_friendly_id%":"b9d21fffb897-pipe-layer-team-lead","%breezy_created_date%":"2026-09-03T19:48:41.429Z","%breezy_updated_date%":"2026-09-03T19:49:26.416Z","%_wpgmp_location_city%":"Dulles","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dulles, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9639112","%_wpgmp_metabox_longitude%":"-77.4496269","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"720"}},"id":3990,"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    Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-14\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","address":"Dulles, VA, USA","location":{"lat":"38.9639112","city":"Dulles","state":"VA","country":"United States","lng":"-77.4496269","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-14\/","zoom":19,"extra_fields":{"post_excerpt":"Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","post_content":"<p><strong>Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352)<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 352 (Mass Excavation Configuration)<\/p>\n<p><strong>Move Massive Dirt \u2013 Power Large-Scale Site Development!<\/strong><\/p>\n<p>Are you a heavy-equipment professional who knows how to move dirt fast and keep haul trucks moving smoothly? We are hiring a <strong>Mass Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this role, you\u2019ll take command of a high-production <strong>CAT 352 (Mass Excavation Configuration)<\/strong> to tackle heavy bulk cuts and fills, construct haul roads and building pads, and work alongside underground utility teams on major civil projects.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>High-Volume Dirt Production:<\/strong> Masterfully operate a <strong>CAT 352 Mass Excavation Excavator<\/strong> for bulk earthmoving, heavy cut\/fill operations, and site clearing.<\/li><li><strong>Rapid Truck Loading:<\/strong> Load off-road and highway haul trucks safely, evenly, and rapidly to keep production cycle times at peak efficiency.<\/li><li><strong>Site Infrastructure:<\/strong> Build smooth haul roads, construct building pads, and shape mass site contours to exact project plan specifications.<\/li><li><strong>Underground Utility Support:<\/strong> Perform deep bulk excavations and ground prep to support underground utility installation crews.<\/li><li><strong>Equipment Maintenance &amp; Daily Logging:<\/strong> Complete required <strong>daily equipment logs<\/strong>, conduct daily walkarounds, manage fluid levels, grease key points, and report mechanical needs.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on mass earthwork, bulk cut\/fill, and site development projects.<\/li><li><strong>Site Skills:<\/strong> Proven expertise in rapid truck loading, pad building, and haul road creation.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Utility Awareness:<\/strong> Familiarity working around or prepping ground for underground utility infrastructure.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-14\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Dulles","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Dulles, VA","%education%":"","%department%":"TSG","%description%":"<p><strong>Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352)<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 352 (Mass Excavation Configuration)<\/p>\n<p><strong>Move Massive Dirt \u2013 Power Large-Scale Site Development!<\/strong><\/p>\n<p>Are you a heavy-equipment professional who knows how to move dirt fast and keep haul trucks moving smoothly? We are hiring a <strong>Mass Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this role, you\u2019ll take command of a high-production <strong>CAT 352 (Mass Excavation Configuration)<\/strong> to tackle heavy bulk cuts and fills, construct haul roads and building pads, and work alongside underground utility teams on major civil projects.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>High-Volume Dirt Production:<\/strong> Masterfully operate a <strong>CAT 352 Mass Excavation Excavator<\/strong> for bulk earthmoving, heavy cut\/fill operations, and site clearing.<\/li><li><strong>Rapid Truck Loading:<\/strong> Load off-road and highway haul trucks safely, evenly, and rapidly to keep production cycle times at peak efficiency.<\/li><li><strong>Site Infrastructure:<\/strong> Build smooth haul roads, construct building pads, and shape mass site contours to exact project plan specifications.<\/li><li><strong>Underground Utility Support:<\/strong> Perform deep bulk excavations and ground prep to support underground utility installation crews.<\/li><li><strong>Equipment Maintenance &amp; Daily Logging:<\/strong> Complete required <strong>daily equipment logs<\/strong>, conduct daily walkarounds, manage fluid levels, grease key points, and report mechanical needs.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on mass earthwork, bulk cut\/fill, and site development projects.<\/li><li><strong>Site Skills:<\/strong> Proven expertise in rapid truck loading, pad building, and haul road creation.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Utility Awareness:<\/strong> Familiarity working around or prepping ground for underground utility infrastructure.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/f963e8fe0320-excavator-operator","%breezy_id%":"f963e8fe0320","%breezy_friendly_id%":"f963e8fe0320-excavator-operator","%breezy_created_date%":"2026-09-03T19:59:24.335Z","%breezy_updated_date%":"2026-09-03T20:00:46.686Z","%_wpgmp_location_city%":"Dulles","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dulles, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9639112","%_wpgmp_metabox_longitude%":"-77.4496269","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"721"}},"id":3991,"infowindow_disable":false},{"source":"post","title":"General Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-5\/\" name=\"General Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;","address":"Dulles, VA, USA","location":{"lat":"38.9639112","city":"Dulles","state":"VA","country":"United States","lng":"-77.4496269","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-5\/","zoom":19,"extra_fields":{"post_excerpt":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;","post_content":"<p><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><\/p>\n<p><strong>Build Your Career in Heavy Construction<\/strong><\/p>\n<p>Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects.<\/p>\n<p>No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p>\n<p><strong>Your Development Path<\/strong><\/p>\n<p>We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p>\n<ol><li><strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li><li><strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li><li><strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li><\/ol>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li><li><strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li><li><strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li><li><strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li><li><strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li><li><strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"General Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Dulles","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Dulles, VA","%education%":"","%department%":"TSG","%description%":"<p><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><\/p>\n<p><strong>Build Your Career in Heavy Construction<\/strong><\/p>\n<p>Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects.<\/p>\n<p>No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p>\n<p><strong>Your Development Path<\/strong><\/p>\n<p>We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p>\n<ol><li><strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li><li><strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li><li><strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li><\/ol>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li><li><strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li><li><strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li><li><strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li><li><strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li><li><strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b0a21fb18942-general-construction-laborer","%breezy_id%":"b0a21fb18942","%breezy_friendly_id%":"b0a21fb18942-general-construction-laborer","%breezy_created_date%":"2026-09-03T20:02:52.611Z","%breezy_updated_date%":"2026-09-03T20:03:20.256Z","%_wpgmp_location_city%":"Dulles","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dulles, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9639112","%_wpgmp_metabox_longitude%":"-77.4496269","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"722"}},"id":3992,"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    Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-15\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","address":"Dulles, VA, USA","location":{"lat":"38.9639112","city":"Dulles","state":"VA","country":"United States","lng":"-77.4496269","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-15\/","zoom":19,"extra_fields":{"post_excerpt":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","post_content":"<p><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p>\n<p><strong>Reports To:<\/strong> Team Lead<\/p>\n<p><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p>\n<p>Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li><li><strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li><li><strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li><li><strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li><li><strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li><li><strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-15\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Dulles","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Dulles, VA","%education%":"","%department%":"TSG","%description%":"<p><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p>\n<p><strong>Location:<\/strong> Front Royal, VA<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p>\n<p><strong>Reports To:<\/strong> Team Lead<\/p>\n<p><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p>\n<p>Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Front Royal, VA<\/strong>.<\/p>\n<p>In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li><li><strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li><li><strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li><li><strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li><li><strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li><li><strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b2c4f1cd3da8-excavator-operator","%breezy_id%":"b2c4f1cd3da8","%breezy_friendly_id%":"b2c4f1cd3da8-excavator-operator","%breezy_created_date%":"2026-09-03T20:07:34.649Z","%breezy_updated_date%":"2026-09-03T20:08:05.719Z","%_wpgmp_location_city%":"Dulles","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dulles, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9639112","%_wpgmp_metabox_longitude%":"-77.4496269","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"723"}},"id":3993,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Haul Truck Driver \u2013 Heavy Equipment Operator Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-3\/\" name=\"Haul Truck Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Haul Truck Driver \u2013 Heavy Equipment Operator Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;","address":"Washington, DC, USA","location":{"lat":"38.9072873","city":"Washington","state":"DC","country":"United States","lng":"-77.0369274","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-3\/","zoom":19,"extra_fields":{"post_excerpt":"Haul Truck Driver \u2013 Heavy Equipment Operator Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;","post_content":"<p><strong>Haul Truck Driver \u2013 Heavy Equipment Operator<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 730 \/ CAT 740 Articulated Haul Trucks<\/p>\n<p><\/p>\n<p>Are you a skilled operator who takes pride in driving heavy iron and keeping civil jobsites moving? We are hiring a dependable, safety-focused <strong>Haul Truck Driver<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>You will primarily pilot <strong>CAT 730 and 740 haul trucks<\/strong> on active underground utility projects, with opportunities to operate secondary support machinery like skid steers and small wheel loaders.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Haul Truck Operations:<\/strong> Safely operate <strong>CAT 730 and 740 articulated haul trucks<\/strong> to haul soil, aggregate, backfill, and rock across underground utility construction sites.<\/li><li><strong>Versatile Equipment Support:<\/strong> Occasionally operate support equipment such as <strong>skid steers and small wheel loaders<\/strong> for site staging, backfilling, and material movement.<\/li><li><strong>Pre\/Post-Trip Inspections:<\/strong> Perform daily pre-trip and post-trip equipment safety checks (fluids, hydraulics, tires, lights) to ensure machine reliability.<\/li><li><strong>Daily Logging:<\/strong> Accurately complete daily logs, maintenance sheets, and material load tallies.<\/li><li><strong>Jobsite Collaboration:<\/strong> Coordinate closely with site superintendents, excavator operators, and pipe crews for efficient site flow and safety.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>2+ years of experience preferred<\/strong> operating articulated haul trucks (CAT 730\/740 or similar civil earthmoving equipment).<\/li><li><strong>Equipment Versatility:<\/strong> Ability or willingness to occasionally jump into skid steers and small wheel loaders when needed.<\/li><li><strong>Certifications:<\/strong> OSHA 10 preferred and a valid drivers license.<\/li><li><strong>Utility Site Knowledge:<\/strong> Familiarity with civil site earthmoving and underground utility construction environments.<\/li><li><strong>Reliability:<\/strong> Strong commitment to daily pre\/post-trip safety checks, daily logging, and punctual attendance.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Haul Truck Operator","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Washington","%location_state_id%":"DC","%location_state_name%":"Dist. of Columbia","%location_city_state%":"Washington, DC","%education%":"","%department%":"TSG","%description%":"<p><strong>Haul Truck Driver \u2013 Heavy Equipment Operator<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 730 \/ CAT 740 Articulated Haul Trucks<\/p>\n<p><\/p>\n<p>Are you a skilled operator who takes pride in driving heavy iron and keeping civil jobsites moving? We are hiring a dependable, safety-focused <strong>Haul Truck Driver<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>You will primarily pilot <strong>CAT 730 and 740 haul trucks<\/strong> on active underground utility projects, with opportunities to operate secondary support machinery like skid steers and small wheel loaders.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Haul Truck Operations:<\/strong> Safely operate <strong>CAT 730 and 740 articulated haul trucks<\/strong> to haul soil, aggregate, backfill, and rock across underground utility construction sites.<\/li><li><strong>Versatile Equipment Support:<\/strong> Occasionally operate support equipment such as <strong>skid steers and small wheel loaders<\/strong> for site staging, backfilling, and material movement.<\/li><li><strong>Pre\/Post-Trip Inspections:<\/strong> Perform daily pre-trip and post-trip equipment safety checks (fluids, hydraulics, tires, lights) to ensure machine reliability.<\/li><li><strong>Daily Logging:<\/strong> Accurately complete daily logs, maintenance sheets, and material load tallies.<\/li><li><strong>Jobsite Collaboration:<\/strong> Coordinate closely with site superintendents, excavator operators, and pipe crews for efficient site flow and safety.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>2+ years of experience preferred<\/strong> operating articulated haul trucks (CAT 730\/740 or similar civil earthmoving equipment).<\/li><li><strong>Equipment Versatility:<\/strong> Ability or willingness to occasionally jump into skid steers and small wheel loaders when needed.<\/li><li><strong>Certifications:<\/strong> OSHA 10 preferred and a valid drivers license.<\/li><li><strong>Utility Site Knowledge:<\/strong> Familiarity with civil site earthmoving and underground utility construction environments.<\/li><li><strong>Reliability:<\/strong> Strong commitment to daily pre\/post-trip safety checks, daily logging, and punctual attendance.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/efae39b38152-haul-truck-operator","%breezy_id%":"efae39b38152","%breezy_friendly_id%":"efae39b38152-haul-truck-operator","%breezy_created_date%":"2026-09-03T18:09:44.924Z","%breezy_updated_date%":"2026-09-03T18:11:12.732Z","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"DC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Washington, DC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9072873","%_wpgmp_metabox_longitude%":"-77.0369274","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"709"}},"id":3979,"infowindow_disable":false},{"source":"post","title":"Project Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Lead \u2013 Site Development &amp; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-lead-4\/\" name=\"Project Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Lead \u2013 Site Development &amp; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;","address":"Washington, DC, USA","location":{"lat":"38.9072873","city":"Washington","state":"DC","country":"United States","lng":"-77.0369274","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-lead-4\/","zoom":19,"extra_fields":{"post_excerpt":"Project Lead \u2013 Site Development &amp; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;","post_content":"<p><strong>Project Lead \u2013 Site Development &amp; Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Software System:<\/strong> HeavyJob<\/p>\n<p><strong>Drive Projects. Direct Crews. Master the Dirt &amp; Utilities!<\/strong><\/p>\n<p>Are you an experienced civil construction leader who knows how to run a jobsite with precision and accountability? We are hiring a <strong>Project Lead<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you will serve as the operational anchor for site development and underground utility projects\u2014managing budgets, schedules, subcontractors, and municipal inspectors in <strong>HeavyJob<\/strong>, while retaining the hands-on skill to operate heavy equipment when the job demands it.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Multi-Crew Leadership:<\/strong> Schedule, direct, and mentor multiple field crews across site prep, bulk earthmoving, and underground utility installations (storm, sanitary, water).<\/li><li><strong>Budget &amp; Schedule Accountability:<\/strong> Manage daily project costs and schedules, optimize labor and machine utilization, and track production in <strong>HeavyJob<\/strong>.<\/li><li><strong>Subcontractor &amp; Inspector Coordination:<\/strong> Coordinate subcontractor workflows and build working relationships with municipal inspectors to secure project sign-offs.<\/li><li><strong>Hands-On Field Operations:<\/strong> Lead from the front by operating heavy equipment when needed\u2014including excavators, dozers, loaders, haul trucks, and pipelaying equipment.<\/li><li><strong>Safety &amp; Daily Reporting:<\/strong> Enforce OSHA safety standards, track daily logs and job yields, and maintain site compliance.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years<\/strong> in site development and underground utility construction.<\/li><li><strong>Leadership Track Record:<\/strong> <strong>2\u20133 years<\/strong> of experience running complete civil projects and directing multiple crews.<\/li><li><strong>Software &amp; Equipment Skills:<\/strong> Hands-on proficiency using <strong>HeavyJob<\/strong>; practical ability to operate dozers, loaders, excavators, dump trucks, and pipelaying gear.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (<strong>OSHA 30 preferred<\/strong>)&nbsp;and <strong>Trench &amp; Excavation Competent Person Certification<\/strong> (Preferred)<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Project Lead","post_link":"https:\/\/turnerstaffing.com\/position\/project-lead-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Washington","%location_state_id%":"DC","%location_state_name%":"Dist. of Columbia","%location_city_state%":"Washington, DC","%education%":"","%department%":"TSG","%description%":"<p><strong>Project Lead \u2013 Site Development &amp; Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Software System:<\/strong> HeavyJob<\/p>\n<p><strong>Drive Projects. Direct Crews. Master the Dirt &amp; Utilities!<\/strong><\/p>\n<p>Are you an experienced civil construction leader who knows how to run a jobsite with precision and accountability? We are hiring a <strong>Project Lead<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you will serve as the operational anchor for site development and underground utility projects\u2014managing budgets, schedules, subcontractors, and municipal inspectors in <strong>HeavyJob<\/strong>, while retaining the hands-on skill to operate heavy equipment when the job demands it.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Multi-Crew Leadership:<\/strong> Schedule, direct, and mentor multiple field crews across site prep, bulk earthmoving, and underground utility installations (storm, sanitary, water).<\/li><li><strong>Budget &amp; Schedule Accountability:<\/strong> Manage daily project costs and schedules, optimize labor and machine utilization, and track production in <strong>HeavyJob<\/strong>.<\/li><li><strong>Subcontractor &amp; Inspector Coordination:<\/strong> Coordinate subcontractor workflows and build working relationships with municipal inspectors to secure project sign-offs.<\/li><li><strong>Hands-On Field Operations:<\/strong> Lead from the front by operating heavy equipment when needed\u2014including excavators, dozers, loaders, haul trucks, and pipelaying equipment.<\/li><li><strong>Safety &amp; Daily Reporting:<\/strong> Enforce OSHA safety standards, track daily logs and job yields, and maintain site compliance.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years<\/strong> in site development and underground utility construction.<\/li><li><strong>Leadership Track Record:<\/strong> <strong>2\u20133 years<\/strong> of experience running complete civil projects and directing multiple crews.<\/li><li><strong>Software &amp; Equipment Skills:<\/strong> Hands-on proficiency using <strong>HeavyJob<\/strong>; practical ability to operate dozers, loaders, excavators, dump trucks, and pipelaying gear.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (<strong>OSHA 30 preferred<\/strong>)&nbsp;and <strong>Trench &amp; Excavation Competent Person Certification<\/strong> (Preferred)<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"Management","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/796c156c5fcd-project-lead","%breezy_id%":"796c156c5fcd","%breezy_friendly_id%":"796c156c5fcd-project-lead","%breezy_created_date%":"2026-09-03T18:18:37.093Z","%breezy_updated_date%":"2026-09-03T18:19:43.175Z","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"DC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Washington, DC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9072873","%_wpgmp_metabox_longitude%":"-77.0369274","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"710"}},"id":3980,"infowindow_disable":false},{"source":"post","title":"Pipe Layer &#8211; Team Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Pipe Layer &#8211; Team Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Team Lead Pipe Layer \u2013 Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-layer-team-lead\/\" name=\"Pipe Layer &#8211; Team Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;","address":"Washington, DC, USA","location":{"lat":"38.9072873","city":"Washington","state":"DC","country":"United States","lng":"-77.0369274","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pipe-layer-team-lead\/","zoom":19,"extra_fields":{"post_excerpt":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;","post_content":"<p><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p>\n<p><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p>\n<p>Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li><li><strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li><li><strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li><li><strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li><li><strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li><li><strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li><li><strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Pipe Layer &#8211; Team Lead","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-layer-team-lead\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Washington","%location_state_id%":"DC","%location_state_name%":"Dist. of Columbia","%location_city_state%":"Washington, DC","%education%":"","%department%":"TSG","%description%":"<p><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p>\n<p><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p>\n<p>Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li><li><strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li><li><strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li><li><strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li><li><strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li><li><strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li><li><strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li><li><strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ce7daa39a261-pipe-layer-team-lead","%breezy_id%":"ce7daa39a261","%breezy_friendly_id%":"ce7daa39a261-pipe-layer-team-lead","%breezy_created_date%":"2026-09-03T18:22:51.558Z","%breezy_updated_date%":"2026-09-03T18:24:10.112Z","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"DC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Washington, DC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9072873","%_wpgmp_metabox_longitude%":"-77.0369274","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"711"}},"id":3981,"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    Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-11\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","address":"Washington, DC, USA","location":{"lat":"38.9072873","city":"Washington","state":"DC","country":"United States","lng":"-77.0369274","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-11\/","zoom":19,"extra_fields":{"post_excerpt":"Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","post_content":"<p><strong>Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352)<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 352 (Mass Excavation Configuration)<\/p>\n<p><strong>Move Massive Dirt \u2013 Power Large-Scale Site Development!<\/strong><\/p>\n<p>Are you a heavy-equipment professional who knows how to move dirt fast and keep haul trucks moving smoothly? We are hiring a <strong>Mass Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you\u2019ll take command of a high-production <strong>CAT 352 (Mass Excavation Configuration)<\/strong> to tackle heavy bulk cuts and fills, construct haul roads and building pads, and work alongside underground utility teams on major civil projects.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>High-Volume Dirt Production:<\/strong> Masterfully operate a <strong>CAT 352 Mass Excavation Excavator<\/strong> for bulk earthmoving, heavy cut\/fill operations, and site clearing.<\/li><li><strong>Rapid Truck Loading:<\/strong> Load off-road and highway haul trucks safely, evenly, and rapidly to keep production cycle times at peak efficiency.<\/li><li><strong>Site Infrastructure:<\/strong> Build smooth haul roads, construct building pads, and shape mass site contours to exact project plan specifications.<\/li><li><strong>Underground Utility Support:<\/strong> Perform deep bulk excavations and ground prep to support underground utility installation crews.<\/li><li><strong>Equipment Maintenance &amp; Daily Logging:<\/strong> Complete required <strong>daily equipment logs<\/strong>, conduct daily walkarounds, manage fluid levels, grease key points, and report mechanical needs.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on mass earthwork, bulk cut\/fill, and site development projects.<\/li><li><strong>Site Skills:<\/strong> Proven expertise in rapid truck loading, pad building, and haul road creation.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Utility Awareness:<\/strong> Familiarity working around or prepping ground for underground utility infrastructure.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-11\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Washington","%location_state_id%":"DC","%location_state_name%":"Dist. of Columbia","%location_city_state%":"Washington, DC","%education%":"","%department%":"TSG","%description%":"<p><strong>Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352)<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 352 (Mass Excavation Configuration)<\/p>\n<p><strong>Move Massive Dirt \u2013 Power Large-Scale Site Development!<\/strong><\/p>\n<p>Are you a heavy-equipment professional who knows how to move dirt fast and keep haul trucks moving smoothly? We are hiring a <strong>Mass Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you\u2019ll take command of a high-production <strong>CAT 352 (Mass Excavation Configuration)<\/strong> to tackle heavy bulk cuts and fills, construct haul roads and building pads, and work alongside underground utility teams on major civil projects.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>High-Volume Dirt Production:<\/strong> Masterfully operate a <strong>CAT 352 Mass Excavation Excavator<\/strong> for bulk earthmoving, heavy cut\/fill operations, and site clearing.<\/li><li><strong>Rapid Truck Loading:<\/strong> Load off-road and highway haul trucks safely, evenly, and rapidly to keep production cycle times at peak efficiency.<\/li><li><strong>Site Infrastructure:<\/strong> Build smooth haul roads, construct building pads, and shape mass site contours to exact project plan specifications.<\/li><li><strong>Underground Utility Support:<\/strong> Perform deep bulk excavations and ground prep to support underground utility installation crews.<\/li><li><strong>Equipment Maintenance &amp; Daily Logging:<\/strong> Complete required <strong>daily equipment logs<\/strong>, conduct daily walkarounds, manage fluid levels, grease key points, and report mechanical needs.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on mass earthwork, bulk cut\/fill, and site development projects.<\/li><li><strong>Site Skills:<\/strong> Proven expertise in rapid truck loading, pad building, and haul road creation.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Utility Awareness:<\/strong> Familiarity working around or prepping ground for underground utility infrastructure.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/988aecc9911f-excavator-operator","%breezy_id%":"988aecc9911f","%breezy_friendly_id%":"988aecc9911f-excavator-operator","%breezy_created_date%":"2026-09-03T18:26:58.813Z","%breezy_updated_date%":"2026-09-03T18:35:48.749Z","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"DC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Washington, DC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9072873","%_wpgmp_metabox_longitude%":"-77.0369274","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"712"}},"id":3982,"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    Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-12\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","address":"Washington, DC, USA","location":{"lat":"38.9072873","city":"Washington","state":"DC","country":"United States","lng":"-77.0369274","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-12\/","zoom":19,"extra_fields":{"post_excerpt":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","post_content":"<p><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p>\n<p><strong>Reports To:<\/strong> Team Lead<\/p>\n<p><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p>\n<p>Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li><li><strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li><li><strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li><li><strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li><li><strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li><li><strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-12\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Washington","%location_state_id%":"DC","%location_state_name%":"Dist. of Columbia","%location_city_state%":"Washington, DC","%education%":"","%department%":"TSG","%description%":"<p><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p>\n<p><strong>Reports To:<\/strong> Team Lead<\/p>\n<p><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p>\n<p>Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li><li><strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li><li><strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li><li><strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li><li><strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li><li><strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li><li><strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li><li><strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/e5f4e43f637f-excavator-operator","%breezy_id%":"e5f4e43f637f","%breezy_friendly_id%":"e5f4e43f637f-excavator-operator","%breezy_created_date%":"2026-09-03T18:30:48.273Z","%breezy_updated_date%":"2026-09-03T18:31:45.015Z","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"DC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Washington, DC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9072873","%_wpgmp_metabox_longitude%":"-77.0369274","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"713"}},"id":3983,"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    Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Charles Town, WV Position Type: Direct Placement (Full-Time,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-5\/\" name=\"Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Charles Town, WV Position Type: Direct Placement (Full-Time,&hellip;","address":"Washington, DC, USA","location":{"lat":"38.9072873","city":"Washington","state":"DC","country":"United States","lng":"-77.0369274","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-5\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Charles Town, WV Position Type: Direct Placement (Full-Time,&hellip;","post_content":"<p><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p>\n<p><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p>\n<p>Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li><li><strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li><li><strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li><li><strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li><li><strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li><li><strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li><\/ul>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Washington","%location_state_id%":"DC","%location_state_name%":"Dist. of Columbia","%location_city_state%":"Washington, DC","%education%":"","%department%":"TSG","%description%":"<p><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p>\n<p><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p>\n<p>Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li><li><strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li><li><strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li><li><strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li><li><strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li><li><strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/f213ca488d56-loader-operator","%breezy_id%":"f213ca488d56","%breezy_friendly_id%":"f213ca488d56-loader-operator","%breezy_created_date%":"2026-09-03T18:34:01.369Z","%breezy_updated_date%":"2026-09-03T18:34:52.039Z","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"DC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Washington, DC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9072873","%_wpgmp_metabox_longitude%":"-77.0369274","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"714"}},"id":3984,"infowindow_disable":false},{"source":"post","title":"General Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-4\/\" name=\"General Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;","address":"Washington, DC, USA","location":{"lat":"38.9072873","city":"Washington","state":"DC","country":"United States","lng":"-77.0369274","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-4\/","zoom":19,"extra_fields":{"post_excerpt":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;","post_content":"<p><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><\/p>\n<p><strong>Build Your Career in Heavy Construction<\/strong><\/p>\n<p>Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p>\n<p><strong>Your Development Path<\/strong><\/p>\n<p>We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p>\n<ol><li><strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li><li><strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li><li><strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li><\/ol>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li><li><strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li><li><strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li><li><strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li><li><strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li><li><strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"General Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Washington","%location_state_id%":"DC","%location_state_name%":"Dist. of Columbia","%location_city_state%":"Washington, DC","%education%":"","%department%":"TSG","%description%":"<p><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p>\n<p><strong>Location:<\/strong> Charles Town, WV<\/p>\n<p><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p>\n<p><\/p>\n<p><strong>Build Your Career in Heavy Construction<\/strong><\/p>\n<p>Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects in <strong>Charles Town, WV<\/strong>.<\/p>\n<p>No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p>\n<p><strong>Your Development Path<\/strong><\/p>\n<p>We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p>\n<ol><li><strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li><li><strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li><li><strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li><\/ol>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li><strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li><li><strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li><li><strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li><li><strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li><\/ul>\n<p><strong>Candidate Requirements<\/strong><\/p>\n<ul><li><strong>Driver's License:<\/strong> Valid Driver's License required.<\/li><li><strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li><li><strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li><li><strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/4d2ee05b846b-general-construction-laborer","%breezy_id%":"4d2ee05b846b","%breezy_friendly_id%":"4d2ee05b846b-general-construction-laborer","%breezy_created_date%":"2026-09-03T18:38:47.558Z","%breezy_updated_date%":"2026-09-03T18:40:36.794Z","%_wpgmp_location_city%":"Washington","%_wpgmp_location_state%":"DC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Washington, DC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9072873","%_wpgmp_metabox_longitude%":"-77.0369274","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"715"}},"id":3985,"infowindow_disable":false},{"source":"post","title":"Crushing Plant Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Crushing Plant Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Crushing Plant Electrician Location: Hinkley, CA Employment Type: Full-Time POSITION SUMMARY Turner Staffing Group is partnered with a mining company&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/crushing-plant-electrician\/\" name=\"Crushing Plant Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Crushing Plant Electrician Location: Hinkley, CA Employment Type: Full-Time POSITION SUMMARY Turner Staffing Group is partnered with a mining company&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\/crushing-plant-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"Crushing Plant Electrician Location: Hinkley, CA Employment Type: Full-Time POSITION SUMMARY Turner Staffing Group is partnered with a mining company&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Crushing Plant Electrician<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location: <\/strong>Hinkley, CA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Employment Type: <\/strong>Full-Time<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>POSITION SUMMARY<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is partnered with a mining company in Hinkley, CA that is hiring a Crushing Plant Electrician. This role is responsible for the mechanical and electrical maintenance, troubleshooting, and repair of plant assets \u2014 jaw crushers, cone crushers, impact crushers, feeders, stackers, conveyors, and associated structural and electrical infrastructure. This position keeps the plant running at full production capacity by diagnosing and correcting electrical, mechanical, hydraulic, and pneumatic failures, and by performing preventive maintenance that minimizes unplanned downtime.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The ideal candidate is equally comfortable inside a control panel, on a ladder, or turning a wrench on stationary equipment, and treats safety and uptime as the most important factors.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>THIS POSITION REQUIRES THAT THE CANDIDATE POSSESS AND MAINTAIN AN ACTIVE ELECTRICIAN LICENSE. CANDIDATES WHO DO NOT POSSESS THAT LICENSE WILL NOT BE CONSIDERED.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>KEY RESPONSIBILITIES<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Diagnose, repair, and maintain electrical issues affecting crushing plants, screening plants, cone crushers, impact crushers, feeders, stackers, and conveyors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Troubleshoot and repair plant electrical systems such as electric motors, motor starters, soft starters, variable frequency drives (VFDs), motor control centers (MCCs), transformers, switchgears, circuit breakers, disconnects, sensors, limit switches, solenoids, and control panels<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform preventive maintenance (PM) on all stationary plant assets per PM schedules<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Troubleshoot electrical faults on plant machinery and components<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Install conduit, cable tray, wire, and electrical components for new plant equipment and expansions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Read and interpret electrical drawings, one-line diagrams, wiring schematics, and equipment manuals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work closely with plant operators and mechanics to quickly diagnose equipment failures<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Respond to plant breakdowns, prioritizing safety and minimizing production downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain portable and stationary generators and assist with generator installations and hookups<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Troubleshoot automatic transfer switches (ATS) and generator control systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Monitor electrical loads and assist with balancing plant power requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate electrical tie-ins for temporary and permanent plant installations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Inspect motors, wiring, junction boxes, disconnects, breakers, and control panels<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform infrared inspections when applicable<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain accurate maintenance records, work orders, and parts usage, and offer recommendations that increase reliability and reduce downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all MSHA regulations and company safety policies<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow lockout\/tagout (LOTO), confined space, fall protection, and all site safety procedures without exception while working safely around 120V, 240V, 480V, and medium-voltage systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in an on-call rotation for after-hours and weekend plant breakdowns<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Other duties as assigned<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>FIT FOR DUTY REQUIREMENTS<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Medical Fitness: <\/strong>Candidates to whom an offer is made must pass a \u201cFitness for Duty\u201d examination, which may include a physical examination, drug\/alcohol screening, and respiratory function testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Essential Functions: <\/strong>Candidates must be able to perform the essential functions of the job, including but not limited to lifting up to 50 lbs., standing for extended periods, bending, reaching, and stooping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Failure to pass the \u201cFitness for Duty\u201d examination and\/or to demonstrate the ability to safely perform essential functions may result in withdrawal of an offer of employment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>REQUIRED QUALIFICATIONS<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">At least 5 years of experience as an industrial mechanic, industrial electrician, or combination mechanic\/electrician maintaining fixed\/stationary plant equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Must possess and maintain an active electrician license<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with aggregate, mining, quarry, asphalt, cement, or heavy industrial facilities highly preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Solid understanding of industrial electrical systems: electric motors, motor starters, soft starters, VFDs, MCCs, transformers, switchgears, circuit breakers, disconnects, sensors, limit switches, solenoids, control panels, etc.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to read electrical schematics, hydraulic schematics, and wiring diagrams<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong troubleshooting and problem-solving skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in all weather conditions, at heights, and in confined spaces per training and PPE requirements, and to work independently with minimal supervision<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>PREFERRED QUALIFICATIONS<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with crushing plants and aggregate processing equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience wiring new industrial equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of NEC electrical code<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Welding or fabrication experience is a plus<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience operating aerial lifts, forklifts, or telehandlers is a plus<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Understanding of generators and temporary power distribution<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>PHYSICAL REQUIREMENTS<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must be able to lift up to 50 pounds occasionally<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must be able to sit or stand for extended periods<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical stamina and ability to work in various weather conditions<\/li>\n<\/ul><h1 style=\"line-height:1.5;margin:0px\"><br><\/h1>","post_title":"Crushing Plant Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/crushing-plant-electrician\/","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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Crushing Plant Electrician<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location: <\/strong>Hinkley, CA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Employment Type: <\/strong>Full-Time<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>POSITION SUMMARY<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is partnered with a mining company in Hinkley, CA that is hiring a Crushing Plant Electrician. This role is responsible for the mechanical and electrical maintenance, troubleshooting, and repair of plant assets \u2014 jaw crushers, cone crushers, impact crushers, feeders, stackers, conveyors, and associated structural and electrical infrastructure. This position keeps the plant running at full production capacity by diagnosing and correcting electrical, mechanical, hydraulic, and pneumatic failures, and by performing preventive maintenance that minimizes unplanned downtime.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The ideal candidate is equally comfortable inside a control panel, on a ladder, or turning a wrench on stationary equipment, and treats safety and uptime as the most important factors.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>THIS POSITION REQUIRES THAT THE CANDIDATE POSSESS AND MAINTAIN AN ACTIVE ELECTRICIAN LICENSE. CANDIDATES WHO DO NOT POSSESS THAT LICENSE WILL NOT BE CONSIDERED.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>KEY RESPONSIBILITIES<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Diagnose, repair, and maintain electrical issues affecting crushing plants, screening plants, cone crushers, impact crushers, feeders, stackers, and conveyors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Troubleshoot and repair plant electrical systems such as electric motors, motor starters, soft starters, variable frequency drives (VFDs), motor control centers (MCCs), transformers, switchgears, circuit breakers, disconnects, sensors, limit switches, solenoids, and control panels<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform preventive maintenance (PM) on all stationary plant assets per PM schedules<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Troubleshoot electrical faults on plant machinery and components<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Install conduit, cable tray, wire, and electrical components for new plant equipment and expansions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Read and interpret electrical drawings, one-line diagrams, wiring schematics, and equipment manuals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work closely with plant operators and mechanics to quickly diagnose equipment failures<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Respond to plant breakdowns, prioritizing safety and minimizing production downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain portable and stationary generators and assist with generator installations and hookups<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Troubleshoot automatic transfer switches (ATS) and generator control systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Monitor electrical loads and assist with balancing plant power requirements<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate electrical tie-ins for temporary and permanent plant installations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Inspect motors, wiring, junction boxes, disconnects, breakers, and control panels<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform infrared inspections when applicable<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain accurate maintenance records, work orders, and parts usage, and offer recommendations that increase reliability and reduce downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all MSHA regulations and company safety policies<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow lockout\/tagout (LOTO), confined space, fall protection, and all site safety procedures without exception while working safely around 120V, 240V, 480V, and medium-voltage systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in an on-call rotation for after-hours and weekend plant breakdowns<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Other duties as assigned<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>FIT FOR DUTY REQUIREMENTS<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Medical Fitness: <\/strong>Candidates to whom an offer is made must pass a \u201cFitness for Duty\u201d examination, which may include a physical examination, drug\/alcohol screening, and respiratory function testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Essential Functions: <\/strong>Candidates must be able to perform the essential functions of the job, including but not limited to lifting up to 50 lbs., standing for extended periods, bending, reaching, and stooping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Failure to pass the \u201cFitness for Duty\u201d examination and\/or to demonstrate the ability to safely perform essential functions may result in withdrawal of an offer of employment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>REQUIRED QUALIFICATIONS<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">At least 5 years of experience as an industrial mechanic, industrial electrician, or combination mechanic\/electrician maintaining fixed\/stationary plant equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Must possess and maintain an active electrician license<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with aggregate, mining, quarry, asphalt, cement, or heavy industrial facilities highly preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Solid understanding of industrial electrical systems: electric motors, motor starters, soft starters, VFDs, MCCs, transformers, switchgears, circuit breakers, disconnects, sensors, limit switches, solenoids, control panels, etc.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to read electrical schematics, hydraulic schematics, and wiring diagrams<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong troubleshooting and problem-solving skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in all weather conditions, at heights, and in confined spaces per training and PPE requirements, and to work independently with minimal supervision<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>PREFERRED QUALIFICATIONS<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with crushing plants and aggregate processing equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience wiring new industrial equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of NEC electrical code<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Welding or fabrication experience is a plus<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience operating aerial lifts, forklifts, or telehandlers is a plus<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Understanding of generators and temporary power distribution<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>PHYSICAL REQUIREMENTS<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must be able to lift up to 50 pounds occasionally<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must be able to sit or stand for extended periods<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical stamina and ability to work in various weather conditions<\/li>\n<\/ul><h1 style=\"line-height:1.5;margin:0px;\"><br><\/h1>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b20ff1e0af6f-crushing-plant-electrician","%breezy_id%":"b20ff1e0af6f","%breezy_friendly_id%":"b20ff1e0af6f-crushing-plant-electrician","%breezy_created_date%":"2026-08-26T19:17:41.491Z","%breezy_updated_date%":"2026-09-08T22:10:56.438Z","%_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","%rank_math_analytic_object_id%":"702"}},"id":3972,"infowindow_disable":false},{"source":"post","title":"Electrical Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrical Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Heat Trace Technician Company Overview IDE Electric is an electrical contractor based in northeastern Pennsylvania. Our primary focus&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heat-trace-technician\/\" name=\"Electrical Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Heat Trace Technician Company Overview IDE Electric is an electrical contractor based in northeastern Pennsylvania. Our primary focus&hellip;","address":"Harding, PA, USA","location":{"lat":"41.3625794","city":"Harding","state":"PA","country":"United States","lng":"-75.8101945","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heat-trace-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Heat Trace Technician Company Overview IDE Electric is an electrical contractor based in northeastern Pennsylvania. Our primary focus&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Job Title: Heat Trace Technician <\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Company Overview<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">IDE Electric is an electrical contractor based in northeastern Pennsylvania. Our primary focus is currently on the oil and gas division.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Role Summary<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are looking for a reliable individual to join our team as a Heat Trace Technician. This role involves wrapping heat trace and insulation on well pads in preparation for the winter season. This is an excellent entry-level opportunity for motivated candidates, as there is potential for career growth into electrical work.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Instrument tubing and insulate heat trace piping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Troubleshoot glycol system installations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Install 3\/8 to 1\/2-inch stainless steel tubing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Wrap heat trace and insulation on well pads.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Requirements &amp; Physical Demands<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> No prior experience is required; a willingness to work hard is the top priority.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Transportation:<\/strong> A valid driver's license and a reliable vehicle are required for a daily commute.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Tools:<\/strong> Candidates must provide their own basic set of hand tools.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Physical Demands:<\/strong> Must be able to lift 50+ lbs and be willing to perform all work outdoors, regardless of weather conditions.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Contract &amp; Compensation<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Pay:<\/strong> Starting at $20- 25\/hour depending on experience <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Structure:<\/strong> This is a 6-month Turner Staffing placement with the potential to move to a direct hire position with IDE Electric.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Benefits:<\/strong> Benefits are available through Turner Staffing during the initial contract period.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Work Locations<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">All job sites are located in Pennsylvania, including:<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Bradford County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Sullivan County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Susquehanna County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Tioga County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Wyoming County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Electrical Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/heat-trace-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Harding","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Harding, PA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Job Title: Heat Trace Technician <\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Company Overview<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">IDE Electric is an electrical contractor based in northeastern Pennsylvania. Our primary focus is currently on the oil and gas division.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Role Summary<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are looking for a reliable individual to join our team as a Heat Trace Technician. This role involves wrapping heat trace and insulation on well pads in preparation for the winter season. This is an excellent entry-level opportunity for motivated candidates, as there is potential for career growth into electrical work.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Instrument tubing and insulate heat trace piping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Troubleshoot glycol system installations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Install 3\/8 to 1\/2-inch stainless steel tubing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Wrap heat trace and insulation on well pads.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Requirements &amp; Physical Demands<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> No prior experience is required; a willingness to work hard is the top priority.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Transportation:<\/strong> A valid driver's license and a reliable vehicle are required for a daily commute.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Tools:<\/strong> Candidates must provide their own basic set of hand tools.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Physical Demands:<\/strong> Must be able to lift 50+ lbs and be willing to perform all work outdoors, regardless of weather conditions.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Contract &amp; Compensation<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Pay:<\/strong> Starting at $20- 25\/hour depending on experience <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Structure:<\/strong> This is a 6-month Turner Staffing placement with the potential to move to a direct hire position with IDE Electric.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Benefits:<\/strong> Benefits are available through Turner Staffing during the initial contract period.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Work Locations<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">All job sites are located in Pennsylvania, including:<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Bradford County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Sullivan County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Susquehanna County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Tioga County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Wyoming County<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/2adef809d684-electrical-laborer","%breezy_id%":"2adef809d684","%breezy_friendly_id%":"2adef809d684-electrical-laborer","%breezy_created_date%":"2026-08-27T19:34:13.381Z","%breezy_updated_date%":"2026-09-28T18:59:30.490Z","%_wpgmp_location_city%":"Harding","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Harding, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.3625794","%_wpgmp_metabox_longitude%":"-75.8101945","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"703"}},"id":3973,"infowindow_disable":false},{"source":"post","title":"Talent Acquisition Coordinator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Talent Acquisition Coordinator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This project-based position is working for Turner Staffing Group on a client site in the Elko, NV area. As Talent&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/talent-acquisition-coordinator\/\" name=\"Talent Acquisition Coordinator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This project-based position is working for Turner Staffing Group on a client site in the Elko, NV area. As Talent&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\/talent-acquisition-coordinator\/","zoom":19,"extra_fields":{"post_excerpt":"This project-based position is working for Turner Staffing Group on a client site in the Elko, NV area. As Talent&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This project-based position is working for Turner Staffing Group on a client site in the Elko, NV area. As Talent Acquisition Coordinator, you will be the operational engine that fills critical roles on time so our people can keep producing gold at world-class levels.<\/p><h2 style=\"line-height:1.5;margin:0px\">Performance Objectives<\/h2><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Fill 90% of open requisitions within agreed time-to-fill targets by coordinating end-to-end recruiting workflows across Elko-based and remote mine sites.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Source and screen 40+ qualified candidates per month for hourly, technical, and professional roles using our ATS, job boards, and local Nevada networks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Schedule and execute 100% of interviews, assessments, and site visits on time, delivering a consistent candidate experience that reflects NGM\u2019s safety-first culture.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reduce offer-to-start cycle time by 15% through accurate documentation, background checks, and onboarding coordination with HR and operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain 98% data integrity in the ATS so hiring managers and leadership have real-time visibility into pipeline health.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support high-volume campaigns (turnarounds, seasonal hiring) that deliver fully staffed crews without compromising safety or compliance standards.<\/li>\n<\/ul><h2 style=\"line-height:1.5;margin:0px\">Environment &amp; Resources<\/h2><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">You report to the Talent Acquisition Manager and partner daily with site HR, superintendents, and recruiting specialists. You will use Workday (or equivalent ATS), Microsoft 365, and established vendor relationships. Travel to mine sites in Elko County is required; a dedicated recruiting budget and administrative support are provided.<\/p><h2 style=\"line-height:1.5;margin:0px\">Essential Qualifications<\/h2><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preference for 2+ years coordinating high-volume recruiting in industrial, mining, or similar 24\/7 operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to manage 30+ concurrent requisitions while hitting time-to-fill and quality-of-hire metrics.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Hands-on experience with an enterprise ATS and scheduling tools; comfort working with hourly and salaried pipelines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong written and verbal communication that builds trust with hiring managers and candidates in a safety-critical environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver\u2019s license and willingness to travel regularly within Nevada.<\/li>\n<\/ul><h2 style=\"line-height:1.5;margin:0px\">Role Selling Points<\/h2><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Direct impact on the world\u2019s largest gold complex\u2014your work keeps production moving.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Exposure to Barrick-operated best practices and a joint-venture scale few recruiters ever see.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Clear path to grow into a full Recruiter or HR Business Partner role as NGM continues to optimize.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Competitive mining-industry compensation plus the chance to live and work in Nevada\u2019s historic gold country.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">If you thrive on making hiring happen at industrial scale, apply now and help us staff the mines that define global gold production.<\/p>","post_title":"Talent Acquisition Coordinator","post_link":"https:\/\/turnerstaffing.com\/position\/talent-acquisition-coordinator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%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=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This project-based position is working for Turner Staffing Group on a client site in the Elko, NV area. As Talent Acquisition Coordinator, you will be the operational engine that fills critical roles on time so our people can keep producing gold at world-class levels.<\/p><h2 style=\"line-height:1.5;margin:0px;\">Performance Objectives<\/h2><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Fill 90% of open requisitions within agreed time-to-fill targets by coordinating end-to-end recruiting workflows across Elko-based and remote mine sites.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Source and screen 40+ qualified candidates per month for hourly, technical, and professional roles using our ATS, job boards, and local Nevada networks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Schedule and execute 100% of interviews, assessments, and site visits on time, delivering a consistent candidate experience that reflects NGM\u2019s safety-first culture.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reduce offer-to-start cycle time by 15% through accurate documentation, background checks, and onboarding coordination with HR and operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain 98% data integrity in the ATS so hiring managers and leadership have real-time visibility into pipeline health.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support high-volume campaigns (turnarounds, seasonal hiring) that deliver fully staffed crews without compromising safety or compliance standards.<\/li>\n<\/ul><h2 style=\"line-height:1.5;margin:0px;\">Environment &amp; Resources<\/h2><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">You report to the Talent Acquisition Manager and partner daily with site HR, superintendents, and recruiting specialists. You will use Workday (or equivalent ATS), Microsoft 365, and established vendor relationships. Travel to mine sites in Elko County is required; a dedicated recruiting budget and administrative support are provided.<\/p><h2 style=\"line-height:1.5;margin:0px;\">Essential Qualifications<\/h2><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preference for 2+ years coordinating high-volume recruiting in industrial, mining, or similar 24\/7 operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to manage 30+ concurrent requisitions while hitting time-to-fill and quality-of-hire metrics.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Hands-on experience with an enterprise ATS and scheduling tools; comfort working with hourly and salaried pipelines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong written and verbal communication that builds trust with hiring managers and candidates in a safety-critical environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver\u2019s license and willingness to travel regularly within Nevada.<\/li>\n<\/ul><h2 style=\"line-height:1.5;margin:0px;\">Role Selling Points<\/h2><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Direct impact on the world\u2019s largest gold complex\u2014your work keeps production moving.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Exposure to Barrick-operated best practices and a joint-venture scale few recruiters ever see.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Clear path to grow into a full Recruiter or HR Business Partner role as NGM continues to optimize.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Competitive mining-industry compensation plus the chance to live and work in Nevada\u2019s historic gold country.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">If you thrive on making hiring happen at industrial scale, apply now and help us staff the mines that define global gold production.<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/d2a71d0f6e69-talent-acquisition-coordinator","%breezy_id%":"d2a71d0f6e69","%breezy_friendly_id%":"d2a71d0f6e69-talent-acquisition-coordinator","%breezy_created_date%":"2026-08-27T22:19:32.049Z","%breezy_updated_date%":"2026-09-08T21:42:40.930Z","%_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%":"704"}},"id":3974,"infowindow_disable":false},{"source":"post","title":"Mobile Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mobile Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    &nbsp;HEAVY EQUIPMENT MECHANIC If you know diesel engines and heavy equipment, we want to hear from you! We\u2019re looking for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mobile-mechanic\/\" name=\"Mobile Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"&nbsp;HEAVY EQUIPMENT MECHANIC If you know diesel engines and heavy equipment, we want to hear from you! We\u2019re looking for&hellip;","address":"Crawford, TX, USA","location":{"lat":"31.5343308","city":"Crawford","state":"TX","country":"United States","lng":"-97.44307","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mobile-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"&nbsp;HEAVY EQUIPMENT MECHANIC If you know diesel engines and heavy equipment, we want to hear from you! We\u2019re looking for&hellip;","post_content":"<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f527\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;HEAVY EQUIPMENT MECHANIC<\/strong><\/p>\n<p><strong>If you know diesel engines and heavy equipment, we want to hear from you!<\/strong><\/p>\n<p>We\u2019re looking for an experienced <strong>Heavy Equipment\/Diesel Mechanic<\/strong> to keep our equipment running safely and efficiently.<\/p>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f69c\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What You\u2019ll Work On<\/strong><\/p>\n<ul><li>Haul Trucks<\/li><li>Wheel Loaders<\/li><li>Skid Steers<\/li><li>Dozers &amp; Motor Graders<\/li><li>Pickups &amp; other mobile equipment<\/li><\/ul>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f6e0\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What You\u2019ll Do<\/strong><\/p>\n<ul><li>Perform preventative maintenance, troubleshooting &amp; repairs<\/li><li>Diagnose <strong>diesel engines, hydraulics &amp; electrical systems<\/strong><\/li><li>Repair brakes, bearings, axles, wiring, seals and other components<\/li><li>Complete engine\/component overhauls<\/li><li>MIG\/arc welding &amp; torch cutting<\/li><li>Complete work orders and maintenance documentation<\/li><li>Perform equipment safety inspections<\/li><\/ul>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/2b50\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What We\u2019re Looking For<\/strong><\/p>\n<ul><li><strong>3\u20135+ years<\/strong> of heavy equipment\/diesel mechanic experience<\/li><li>Strong diesel troubleshooting skills<\/li><li>Experience with <strong>hydraulics, electrical &amp; welding<\/strong><\/li><li>Safety-focused and dependable<\/li><li>Able to work independently in a fast-paced environment<\/li><li>High School Diploma\/GED required<\/li><li>Technical training is a plus!<\/li><\/ul>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f4aa\/32.png\"><\/figure>\n<p>&nbsp;Must be able to lift 75+ lbs and work in industrial\/outdoor conditions.<\/p>\n<p><strong>Experienced heavy equipment mechanics \u2014 apply today!<\/strong><\/p>\n<p><br>\n\n<\/p>","post_title":"Mobile Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mobile-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Crawford","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crawford, TX","%education%":"Education","%department%":"TSG","%description%":"<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f527\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;HEAVY EQUIPMENT MECHANIC<\/strong><\/p>\n<p><strong>If you know diesel engines and heavy equipment, we want to hear from you!<\/strong><\/p>\n<p>We\u2019re looking for an experienced <strong>Heavy Equipment\/Diesel Mechanic<\/strong> to keep our equipment running safely and efficiently.<\/p>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f69c\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What You\u2019ll Work On<\/strong><\/p>\n<ul><li>Haul Trucks<\/li><li>Wheel Loaders<\/li><li>Skid Steers<\/li><li>Dozers &amp; Motor Graders<\/li><li>Pickups &amp; other mobile equipment<\/li><\/ul>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f6e0\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What You\u2019ll Do<\/strong><\/p>\n<ul><li>Perform preventative maintenance, troubleshooting &amp; repairs<\/li><li>Diagnose <strong>diesel engines, hydraulics &amp; electrical systems<\/strong><\/li><li>Repair brakes, bearings, axles, wiring, seals and other components<\/li><li>Complete engine\/component overhauls<\/li><li>MIG\/arc welding &amp; torch cutting<\/li><li>Complete work orders and maintenance documentation<\/li><li>Perform equipment safety inspections<\/li><\/ul>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/2b50\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What We\u2019re Looking For<\/strong><\/p>\n<ul><li><strong>3\u20135+ years<\/strong> of heavy equipment\/diesel mechanic experience<\/li><li>Strong diesel troubleshooting skills<\/li><li>Experience with <strong>hydraulics, electrical &amp; welding<\/strong><\/li><li>Safety-focused and dependable<\/li><li>Able to work independently in a fast-paced environment<\/li><li>High School Diploma\/GED required<\/li><li>Technical training is a plus!<\/li><\/ul>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f4aa\/32.png\"><\/figure>\n<p>&nbsp;Must be able to lift 75+ lbs and work in industrial\/outdoor conditions.<\/p>\n<p><strong>Experienced heavy equipment mechanics \u2014 apply today!<\/strong><\/p>\n<p><br>\n\n<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/dba863141fc9-mobile-mechanic","%breezy_id%":"dba863141fc9","%breezy_friendly_id%":"dba863141fc9-mobile-mechanic","%breezy_created_date%":"2026-08-28T00:38:18.501Z","%breezy_updated_date%":"2026-09-08T22:39:25.157Z","%_wpgmp_location_city%":"Crawford","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crawford, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.5343308","%_wpgmp_metabox_longitude%":"-97.44307","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"705","%rank_math_og_content_image%":{"check":"43eeb79b7849d4066b6639e7386bdb81","images":[]}}},"id":3975,"infowindow_disable":false},{"source":"post","title":"Pipe Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Pipe Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Pipe Supervisor Summary Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-supervisor\/\" name=\"Pipe Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Pipe Supervisor Summary Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews,&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-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Pipe Supervisor Summary Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews,&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Pipe Supervisor<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Summary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews, equipment, and subcontractors while maintaining customer satisfaction and profitability.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Crew Management: Train, supervise, and support pipe crew; enforce company policies; ensure effective communication with management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety: Promote and enforce safety policies; provide orientations; investigate\/report incidents; maintain first aid\/CPR readiness.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Technical: Review blueprints, contracts, and specs; set and compute grades; calculate quantities; apply soils knowledge; ensure efficient sequencing of work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Project Execution: Plan and schedule activities; monitor costs, productivity, and budgets; avoid rework; track and report progress.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equipment Oversight: Supervise equipment use, maintenance, and security.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Customer &amp; Public Relations: Maintain positive relationships with clients, municipalities, and neighbors; resolve issues professionally.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Administration: Prepare reports, maintain documentation, and attend meetings.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Requirements<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Education\/Experience:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High school diploma or GED.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">5+ years pipe\/utility installation experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">2+ years supervisory experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Skills:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Read\/interpret blueprints and contracts.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong math skills (grades, volumes, tonnage).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Problem-solving and decision-making.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong communication and leadership abilities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Licenses: Valid driver\u2019s license.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical Demands &amp; Environment<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physically fit; able to lift 50+ lbs, stand for long periods, and work in rough terrain.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Exposure to outdoor elements (heat, cold, rain, snow, dust, noise).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Pipe Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-supervisor\/","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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Pipe Supervisor<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Summary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews, equipment, and subcontractors while maintaining customer satisfaction and profitability.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Crew Management: Train, supervise, and support pipe crew; enforce company policies; ensure effective communication with management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety: Promote and enforce safety policies; provide orientations; investigate\/report incidents; maintain first aid\/CPR readiness.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Technical: Review blueprints, contracts, and specs; set and compute grades; calculate quantities; apply soils knowledge; ensure efficient sequencing of work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Project Execution: Plan and schedule activities; monitor costs, productivity, and budgets; avoid rework; track and report progress.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equipment Oversight: Supervise equipment use, maintenance, and security.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Customer &amp; Public Relations: Maintain positive relationships with clients, municipalities, and neighbors; resolve issues professionally.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Administration: Prepare reports, maintain documentation, and attend meetings.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Requirements<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Education\/Experience:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High school diploma or GED.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">5+ years pipe\/utility installation experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">2+ years supervisory experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Skills:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Read\/interpret blueprints and contracts.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong math skills (grades, volumes, tonnage).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Problem-solving and decision-making.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong communication and leadership abilities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Licenses: Valid driver\u2019s license.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical Demands &amp; Environment<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physically fit; able to lift 50+ lbs, stand for long periods, and work in rough terrain.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Exposure to outdoor elements (heat, cold, rain, snow, dust, noise).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/74f6c98f856a-pipe-supervisor","%breezy_id%":"74f6c98f856a","%breezy_friendly_id%":"74f6c98f856a-pipe-supervisor","%breezy_created_date%":"2026-08-28T17:12:30.003Z","%breezy_updated_date%":"2026-09-08T22:42:49.098Z","%_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%":"706"}},"id":3976,"infowindow_disable":false},{"source":"post","title":"Project Controls Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Controls Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Jerritt Canyon The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the property occurred&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-controls-manager\/\" name=\"Project Controls Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Jerritt Canyon The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the property occurred&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\/project-controls-manager\/","zoom":19,"extra_fields":{"post_excerpt":"About Jerritt Canyon The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the property occurred&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>About Jerritt Canyon<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">property occurred in 1981. The Jerritt Canyon property contains 30,821 hectares of mining<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">claims located in the mining-friendly state of Nevada. First Majestic acquired the Jerritt Canyon<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Gold Mine from Sprott Mining Inc. on April 30, 2021. In May 2023, operations were suspended<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">to prioritize exploration and technical studies. Jerritt Canyon is now entering a new phase of<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">evaluation and planning, requiring substantial technical support to advance the work necessary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">for a potential future restart of operations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>The Opportunity<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Project Controls Manager is responsible for leading and managing all project controls functions for<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">capital, sustaining, and infrastructure projects across the operation. This position provides strategic<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">leadership and oversight of project planning, scheduling, cost management, forecasting, reporting, risk<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">management, and change control processes to ensure successful project execution and alignment with<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">business objectives.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Working closely with the Restart Manager, Engineering, Construction, Procurement, Finance, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operations leadership, the Project Controls Manager establishes project controls standards, drives<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">accountability across project teams, identifies risks and opportunities, and delivers critical decision-<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">support information to senior leadership. This role is responsible for developing project controls<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">capabilities, improving project performance, and ensuring projects are delivered safely, on schedule,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">and within approved budgets.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Responsibilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Lead and manage all project controls activities across the project portfolio, including planning,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">scheduling, cost control, forecasting, reporting, risk management, and change management.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Establish and maintain project controls standards, processes, systems, and governance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">frameworks.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Provide strategic oversight of integrated project schedules, ensuring alignment with project<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">objectives, resource plans, and operational priorities.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Lead project budgeting, cost forecasting, cash flow planning, and capital expenditure reporting.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Monitor project performance against approved schedules, budgets, and key performance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">indicators.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Identify project risks, trends, and performance gaps, and develop mitigation and recovery<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">strategies.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Lead earned value management, variance analysis, productivity tracking, and project<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">performance reporting.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Develop and present executive-level project controls reports, dashboards, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">recommendations to senior leadership.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Oversee project change management processes, including evaluation and approval of schedule,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">scope, and cost impacts.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Ensure the accuracy, integrity, and consistency of project controls data, reporting, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">management systems.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Partner with Engineering, Construction, Procurement, Operations, and Finance teams to support<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">project execution and decision-making.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Support contract administration, contractor performance management, and commercial<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">evaluations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Lead project controls personnel, contractors, and consultants, including coaching, mentoring,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">performance management, and professional development.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Drive continuous improvement initiatives to enhance project controls processes, systems, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">project delivery performance.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Promote a strong safety culture and ensure compliance with company policies, governance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">requirements, and regulatory standards.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The above responsibilities are representative and may not include all assigned duties.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Education and Experience<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Bachelor&amp;#39;s degree in Engineering, Construction Management, Mining Engineering, Business<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Administration, or a related field required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 15+ years of progressive experience in project controls, project management, or capital project<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">execution within mining, heavy industrial, or infrastructure environments.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Demonstrated experience leading project controls functions for large-scale capital projects.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Strong knowledge of project scheduling, cost control, forecasting, risk management, and change<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">management principles.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Proficiency with Primavera P6, Microsoft Project, Microsoft Excel, SAP, and Oracle.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Experience leading cross-functional teams and influencing project stakeholders.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 Experience in mining or other heavy industrial operations preferred.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\uf0b7 PMP, CCP, PSP, AACE, or similar professional certification considered an asset.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Equal Employment Opportunity<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Company is an equal employment opportunity employer committed to providing<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">employment opportunities to employees and applicants in accordance with all<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">applicable laws.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Project Controls Manager","post_link":"https:\/\/turnerstaffing.com\/position\/project-controls-manager\/","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=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>About Jerritt Canyon<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Jerritt Canyon deposit was discovered in 1972, and the first gold production from the<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">property occurred in 1981. The Jerritt Canyon property contains 30,821 hectares of mining<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">claims located in the mining-friendly state of Nevada. First Majestic acquired the Jerritt Canyon<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Gold Mine from Sprott Mining Inc. on April 30, 2021. In May 2023, operations were suspended<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">to prioritize exploration and technical studies. Jerritt Canyon is now entering a new phase of<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">evaluation and planning, requiring substantial technical support to advance the work necessary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">for a potential future restart of operations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>The Opportunity<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Project Controls Manager is responsible for leading and managing all project controls functions for<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">capital, sustaining, and infrastructure projects across the operation. This position provides strategic<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">leadership and oversight of project planning, scheduling, cost management, forecasting, reporting, risk<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">management, and change control processes to ensure successful project execution and alignment with<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">business objectives.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Working closely with the Restart Manager, Engineering, Construction, Procurement, Finance, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operations leadership, the Project Controls Manager establishes project controls standards, drives<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">accountability across project teams, identifies risks and opportunities, and delivers critical decision-<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">support information to senior leadership. This role is responsible for developing project controls<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">capabilities, improving project performance, and ensuring projects are delivered safely, on schedule,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">and within approved budgets.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Responsibilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Lead and manage all project controls activities across the project portfolio, including planning,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">scheduling, cost control, forecasting, reporting, risk management, and change management.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Establish and maintain project controls standards, processes, systems, and governance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">frameworks.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Provide strategic oversight of integrated project schedules, ensuring alignment with project<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">objectives, resource plans, and operational priorities.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Lead project budgeting, cost forecasting, cash flow planning, and capital expenditure reporting.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Monitor project performance against approved schedules, budgets, and key performance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">indicators.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Identify project risks, trends, and performance gaps, and develop mitigation and recovery<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">strategies.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Lead earned value management, variance analysis, productivity tracking, and project<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">performance reporting.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Develop and present executive-level project controls reports, dashboards, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">recommendations to senior leadership.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Oversee project change management processes, including evaluation and approval of schedule,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">scope, and cost impacts.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Ensure the accuracy, integrity, and consistency of project controls data, reporting, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">management systems.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Partner with Engineering, Construction, Procurement, Operations, and Finance teams to support<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">project execution and decision-making.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Support contract administration, contractor performance management, and commercial<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">evaluations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Lead project controls personnel, contractors, and consultants, including coaching, mentoring,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">performance management, and professional development.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Drive continuous improvement initiatives to enhance project controls processes, systems, and<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">project delivery performance.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Promote a strong safety culture and ensure compliance with company policies, governance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">requirements, and regulatory standards.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The above responsibilities are representative and may not include all assigned duties.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Education and Experience<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Bachelor&amp;#39;s degree in Engineering, Construction Management, Mining Engineering, Business<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Administration, or a related field required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 15+ years of progressive experience in project controls, project management, or capital project<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">execution within mining, heavy industrial, or infrastructure environments.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Demonstrated experience leading project controls functions for large-scale capital projects.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Strong knowledge of project scheduling, cost control, forecasting, risk management, and change<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">management principles.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Proficiency with Primavera P6, Microsoft Project, Microsoft Excel, SAP, and Oracle.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Experience leading cross-functional teams and influencing project stakeholders.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 Experience in mining or other heavy industrial operations preferred.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\uf0b7 PMP, CCP, PSP, AACE, or similar professional certification considered an asset.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Equal Employment Opportunity<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Company is an equal employment opportunity employer committed to providing<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">employment opportunities to employees and applicants in accordance with all<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">applicable laws.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/4763472bb636-project-controls-manager","%breezy_id%":"4763472bb636","%breezy_friendly_id%":"4763472bb636-project-controls-manager","%breezy_created_date%":"2026-08-31T18:28:49.174Z","%breezy_updated_date%":"2026-08-31T18:28:51.426Z","%_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%":"707"}},"id":3977,"infowindow_disable":false},{"source":"post","title":"Mobile Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mobile Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    &nbsp;HEAVY EQUIPMENT MECHANIC If you know diesel engines and heavy equipment, we want to hear from you! We\u2019re looking for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mobile-mechanic-2\/\" name=\"Mobile Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"&nbsp;HEAVY EQUIPMENT MECHANIC If you know diesel engines and heavy equipment, we want to hear from you! We\u2019re looking for&hellip;","address":"Crawford, TX, USA","location":{"lat":"31.5343308","city":"Crawford","state":"TX","country":"United States","lng":"-97.44307","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mobile-mechanic-2\/","zoom":19,"extra_fields":{"post_excerpt":"&nbsp;HEAVY EQUIPMENT MECHANIC If you know diesel engines and heavy equipment, we want to hear from you! We\u2019re looking for&hellip;","post_content":"<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f527\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;HEAVY EQUIPMENT MECHANIC<\/strong><\/p>\n<p><strong>If you know diesel engines and heavy equipment, we want to hear from you!<\/strong><\/p>\n<p>We\u2019re looking for an experienced <strong>Heavy Equipment\/Diesel Mechanic<\/strong> to keep our equipment running safely and efficiently.<\/p>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f69c\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What You\u2019ll Work On<\/strong><\/p>\n<ul><li>Haul Trucks<\/li><li>Wheel Loaders<\/li><li>Skid Steers<\/li><li>Dozers &amp; Motor Graders<\/li><li>Pickups &amp; other mobile equipment<\/li><\/ul>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f6e0\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What You\u2019ll Do<\/strong><\/p>\n<ul><li>Perform preventative maintenance, troubleshooting &amp; repairs<\/li><li>Diagnose <strong>diesel engines, hydraulics &amp; electrical systems<\/strong><\/li><li>Repair brakes, bearings, axles, wiring, seals and other components<\/li><li>Complete engine\/component overhauls<\/li><li>MIG\/arc welding &amp; torch cutting<\/li><li>Complete work orders and maintenance documentation<\/li><li>Perform equipment safety inspections<\/li><\/ul>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/2b50\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What We\u2019re Looking For<\/strong><\/p>\n<ul><li><strong>3\u20135+ years<\/strong> of heavy equipment\/diesel mechanic experience<\/li><li>Strong diesel troubleshooting skills<\/li><li>Experience with <strong>hydraulics, electrical &amp; welding<\/strong><\/li><li>Safety-focused and dependable<\/li><li>Able to work independently in a fast-paced environment<\/li><li>High School Diploma\/GED required<\/li><li>Technical training is a plus!<\/li><\/ul>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f4aa\/32.png\"><\/figure>\n<p>&nbsp;Must be able to lift 75+ lbs and work in industrial\/outdoor conditions.<\/p>\n<p><strong>Experienced heavy equipment mechanics \u2014 apply today!<\/strong><\/p>\n<p><br>\n\n<\/p>","post_title":"Mobile Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mobile-mechanic-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Crawford","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crawford, TX","%education%":"Some High School Coursework","%department%":"TSG","%description%":"<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f527\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;HEAVY EQUIPMENT MECHANIC<\/strong><\/p>\n<p><strong>If you know diesel engines and heavy equipment, we want to hear from you!<\/strong><\/p>\n<p>We\u2019re looking for an experienced <strong>Heavy Equipment\/Diesel Mechanic<\/strong> to keep our equipment running safely and efficiently.<\/p>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f69c\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What You\u2019ll Work On<\/strong><\/p>\n<ul><li>Haul Trucks<\/li><li>Wheel Loaders<\/li><li>Skid Steers<\/li><li>Dozers &amp; Motor Graders<\/li><li>Pickups &amp; other mobile equipment<\/li><\/ul>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f6e0\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What You\u2019ll Do<\/strong><\/p>\n<ul><li>Perform preventative maintenance, troubleshooting &amp; repairs<\/li><li>Diagnose <strong>diesel engines, hydraulics &amp; electrical systems<\/strong><\/li><li>Repair brakes, bearings, axles, wiring, seals and other components<\/li><li>Complete engine\/component overhauls<\/li><li>MIG\/arc welding &amp; torch cutting<\/li><li>Complete work orders and maintenance documentation<\/li><li>Perform equipment safety inspections<\/li><\/ul>\n<p><strong><\/strong><\/p><strong>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/2b50\/32.png\"><\/figure>\n<\/strong><p><strong>&nbsp;What We\u2019re Looking For<\/strong><\/p>\n<ul><li><strong>3\u20135+ years<\/strong> of heavy equipment\/diesel mechanic experience<\/li><li>Strong diesel troubleshooting skills<\/li><li>Experience with <strong>hydraulics, electrical &amp; welding<\/strong><\/li><li>Safety-focused and dependable<\/li><li>Able to work independently in a fast-paced environment<\/li><li>High School Diploma\/GED required<\/li><li>Technical training is a plus!<\/li><\/ul>\n<figure><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f4aa\/32.png\"><\/figure>\n<p>&nbsp;Must be able to lift 75+ lbs and work in industrial\/outdoor conditions.<\/p>\n<p><strong>Experienced heavy equipment mechanics \u2014 apply today!<\/strong><\/p>\n<p><br>\n\n<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a9198221089c-mobile-mechanic","%breezy_id%":"a9198221089c","%breezy_friendly_id%":"a9198221089c-mobile-mechanic","%breezy_created_date%":"2026-09-01T20:14:14.102Z","%breezy_updated_date%":"2026-09-08T22:39:43.890Z","%_wpgmp_location_city%":"Crawford","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crawford, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.5343308","%_wpgmp_metabox_longitude%":"-97.44307","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"708","%rank_math_og_content_image%":{"check":"43eeb79b7849d4066b6639e7386bdb81","images":[]}}},"id":3978,"infowindow_disable":false},{"source":"post","title":"General Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Build Your Career&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-3\/\" name=\"General Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Build Your Career&hellip;","address":"Hagerstown, MD, USA","location":{"lat":"39.6417629","city":"Hagerstown","state":"MD","country":"United States","lng":"-77.7199932","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-3\/","zoom":19,"extra_fields":{"post_excerpt":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Build Your Career&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Hagerstown, MD<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Build Your Career in Heavy Construction<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Your Development Path<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p><ol style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li>\n<\/ol><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"General Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Hagerstown","%location_state_id%":"MD","%location_state_name%":"Maryland","%location_city_state%":"Hagerstown, MD","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Hagerstown, MD<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Build Your Career in Heavy Construction<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Your Development Path<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p><ol style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li>\n<\/ol><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ad03971ae9ac-general-construction-laborer","%breezy_id%":"ad03971ae9ac","%breezy_friendly_id%":"ad03971ae9ac-general-construction-laborer","%breezy_created_date%":"2026-08-20T20:19:55.793Z","%breezy_updated_date%":"2026-08-20T20:19:57.860Z","%_wpgmp_location_city%":"Hagerstown","%_wpgmp_location_state%":"MD","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hagerstown, MD, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.6417629","%_wpgmp_metabox_longitude%":"-77.7199932","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"695"}},"id":3965,"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    Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent)&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-4\/\" name=\"Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent)&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent)&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location: Hagerstown, MD<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Hagerstown, MD<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location: Hagerstown, MD<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Hagerstown, MD<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/0cd9b93ce83f-loader-operator","%breezy_id%":"0cd9b93ce83f","%breezy_friendly_id%":"0cd9b93ce83f-loader-operator","%breezy_created_date%":"2026-08-20T20:22:24.842Z","%breezy_updated_date%":"2026-08-20T20:22:27.093Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"696"}},"id":3966,"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    Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Primary Machine: CAT&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-10\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Primary Machine: CAT&hellip;","address":"Hagerstown, MD, USA","location":{"lat":"39.6417629","city":"Hagerstown","state":"MD","country":"United States","lng":"-77.7199932","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-10\/","zoom":19,"extra_fields":{"post_excerpt":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Primary Machine: CAT&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Hagerstown, MD<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Hagerstown, MD<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-10\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Hagerstown","%location_state_id%":"MD","%location_state_name%":"Maryland","%location_city_state%":"Hagerstown, MD","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Hagerstown, MD<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Hagerstown, MD<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/f4b97fc037f3-excavator-operator","%breezy_id%":"f4b97fc037f3","%breezy_friendly_id%":"f4b97fc037f3-excavator-operator","%breezy_created_date%":"2026-08-20T20:25:25.910Z","%breezy_updated_date%":"2026-08-20T20:25:28.031Z","%_wpgmp_location_city%":"Hagerstown","%_wpgmp_location_state%":"MD","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hagerstown, MD, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.6417629","%_wpgmp_metabox_longitude%":"-77.7199932","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"697"}},"id":3967,"infowindow_disable":false},{"source":"post","title":"Lead Pipe Layer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Lead Pipe Layer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Team Lead Pipe Layer \u2013 Underground Utilities Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe Lasers,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lead-pipe-layer-3\/\" name=\"Lead Pipe Layer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe Lasers,&hellip;","address":"Hagerstown, MD, USA","location":{"lat":"39.6417629","city":"Hagerstown","state":"MD","country":"United States","lng":"-77.7199932","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/lead-pipe-layer-3\/","zoom":19,"extra_fields":{"post_excerpt":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Hagerstown, MD Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe Lasers,&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Hagerstown, MD<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Hagerstown, MD<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Lead Pipe Layer","post_link":"https:\/\/turnerstaffing.com\/position\/lead-pipe-layer-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Hagerstown","%location_state_id%":"MD","%location_state_name%":"Maryland","%location_city_state%":"Hagerstown, MD","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Hagerstown, MD<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Hagerstown, MD<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/36b6ad8be2d7-lead-pipe-layer","%breezy_id%":"36b6ad8be2d7","%breezy_friendly_id%":"36b6ad8be2d7-lead-pipe-layer","%breezy_created_date%":"2026-08-20T20:27:15.810Z","%breezy_updated_date%":"2026-08-20T20:27:17.808Z","%_wpgmp_location_city%":"Hagerstown","%_wpgmp_location_state%":"MD","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hagerstown, MD, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.6417629","%_wpgmp_metabox_longitude%":"-77.7199932","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"698"}},"id":3968,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Haul Truck Driver \u2013 Heavy Equipment Operator Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-2\/\" name=\"Haul Truck Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Haul Truck Driver \u2013 Heavy Equipment Operator Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;","address":"Charles Town, WV, USA","location":{"lat":"39.2889903","city":"Charles Town","state":"WV","country":"United States","lng":"-77.8597175","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Haul Truck Driver \u2013 Heavy Equipment Operator Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Haul Truck Driver \u2013 Heavy Equipment Operator<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Fleet:<\/strong> CAT 730 \/ CAT 740 Articulated Haul Trucks<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Take the Wheel of Powerful Machinery in Front Royal!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled operator who takes pride in driving heavy iron and keeping civil jobsites moving? We are hiring a dependable, safety-focused <strong>Haul Truck Driver<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">You will primarily pilot <strong>CAT 730 and 740 haul trucks<\/strong> on active underground utility projects, with opportunities to operate secondary support machinery like skid steers and small wheel loaders.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Haul Truck Operations:<\/strong> Safely operate <strong>CAT 730 and 740 articulated haul trucks<\/strong> to haul soil, aggregate, backfill, and rock across underground utility construction sites.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Versatile Equipment Support:<\/strong> Occasionally operate support equipment such as <strong>skid steers and small wheel loaders<\/strong> for site staging, backfilling, and material movement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Pre\/Post-Trip Inspections:<\/strong> Perform daily pre-trip and post-trip equipment safety checks (fluids, hydraulics, tires, lights) to ensure machine reliability.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Logging:<\/strong> Accurately complete daily logs, maintenance sheets, and material load tallies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Jobsite Collaboration:<\/strong> Coordinate closely with site superintendents, excavator operators, and pipe crews for efficient site flow and safety.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>2+ years of experience preferred<\/strong> operating articulated haul trucks (CAT 730\/740 or similar civil earthmoving equipment).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Versatility:<\/strong> Ability or willingness to occasionally jump into skid steers and small wheel loaders when needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> OSHA 10 preferred and a valid drivers license.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Utility Site Knowledge:<\/strong> Familiarity with civil site earthmoving and underground utility construction environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Reliability:<\/strong> Strong commitment to daily pre\/post-trip safety checks, daily logging, and punctual attendance.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Haul Truck Operator","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charles Town","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Charles Town, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Haul Truck Driver \u2013 Heavy Equipment Operator<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Fleet:<\/strong> CAT 730 \/ CAT 740 Articulated Haul Trucks<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Take the Wheel of Powerful Machinery in Front Royal!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled operator who takes pride in driving heavy iron and keeping civil jobsites moving? We are hiring a dependable, safety-focused <strong>Haul Truck Driver<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">You will primarily pilot <strong>CAT 730 and 740 haul trucks<\/strong> on active underground utility projects, with opportunities to operate secondary support machinery like skid steers and small wheel loaders.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Haul Truck Operations:<\/strong> Safely operate <strong>CAT 730 and 740 articulated haul trucks<\/strong> to haul soil, aggregate, backfill, and rock across underground utility construction sites.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Versatile Equipment Support:<\/strong> Occasionally operate support equipment such as <strong>skid steers and small wheel loaders<\/strong> for site staging, backfilling, and material movement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Pre\/Post-Trip Inspections:<\/strong> Perform daily pre-trip and post-trip equipment safety checks (fluids, hydraulics, tires, lights) to ensure machine reliability.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Logging:<\/strong> Accurately complete daily logs, maintenance sheets, and material load tallies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Jobsite Collaboration:<\/strong> Coordinate closely with site superintendents, excavator operators, and pipe crews for efficient site flow and safety.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>2+ years of experience preferred<\/strong> operating articulated haul trucks (CAT 730\/740 or similar civil earthmoving equipment).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Versatility:<\/strong> Ability or willingness to occasionally jump into skid steers and small wheel loaders when needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> OSHA 10 preferred and a valid drivers license.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Utility Site Knowledge:<\/strong> Familiarity with civil site earthmoving and underground utility construction environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Reliability:<\/strong> Strong commitment to daily pre\/post-trip safety checks, daily logging, and punctual attendance.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a6298c015662-haul-truck-operator","%breezy_id%":"a6298c015662","%breezy_friendly_id%":"a6298c015662-haul-truck-operator","%breezy_created_date%":"2026-08-20T21:01:54.754Z","%breezy_updated_date%":"2026-08-20T21:01:57.185Z","%_wpgmp_location_city%":"Charles Town","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charles Town, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2889903","%_wpgmp_metabox_longitude%":"-77.8597175","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"699"}},"id":3969,"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 Project-Based Geologists to support our client&#8217;s mining operations. This opportunity is well suited for geologists&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":"Turner Staffing Group is seeking Project-Based Geologists to support our client&#8217;s mining operations. This opportunity is well suited for geologists&hellip;","address":"Carlin, NV, USA","location":{"lat":"40.7138067","city":"Carlin","state":"NV","country":"United States","lng":"-116.1039663","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking Project-Based Geologists to support our client&#8217;s mining operations. This opportunity is well suited for geologists&hellip;","post_content":"<p style=\"font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is seeking <strong>Project-Based Geologists<\/strong> to support our client's mining operations. This opportunity is well suited for geologists with hands-on experience in geologic mapping, core logging, sampling, and geological data management.<\/p><p style=\"font-family:Arial;font-size:16px;margin:0px;line-height:1.5\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\"><span style=\"font-family:Arial;font-size:16px\">T<\/span>he Geologist will support day-to-day geology activities, including ore routing and tracking, geological mapping, sampling, data entry and validation, and core and RC chip logging. Additional duties may be assigned based on operational needs.<\/p><p style=\"font-family:Arial;font-size:16px;margin:0px;line-height:1.5\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform ore routing and tracking activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct geological mapping and sampling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Complete core logging and RC chip logging.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Enter, review, and validate geological data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain accurate and organized geological records.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support site geology activities and work under the direction of a Senior Geologist.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform other duties as assigned based on operational requirements.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;margin:0px;line-height:1.5\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Bachelor of Science in Geology required.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous geological mapping experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous core logging experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous data entry experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with databases, mapping software, and 3D modeling software is preferred but not required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work effectively within the assigned rotational schedule and in a site-based geology environment.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;margin:0px;line-height:1.5\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Project Details<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Project Duration:<\/strong> Approximately 1 year with possibility of direct hire.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Schedule:<\/strong> 8\/6, 4\/3 rotation.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Work Authorization<\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"font-family:Arial;font-size:16px;margin:0px;line-height:1.5\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">About Turner Staffing Group<\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group provides workforce solutions for organizations across the mining and heavy industrial sectors. This project-based opportunity offers the chance to apply hands-on geology experience in an active mining environment while working alongside experienced industry professionals.<\/p><p style=\"font-family:Arial;font-size:16px;margin:0px;line-height:1.5\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is an equal opportunity employer. Employment decisions are made without regard to legally protected characteristics in accordance with applicable law.<\/p>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%experience%":"","%location_country%":"United States","%location_city%":"Carlin","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Carlin, NV","%education%":"","%department%":"TSG","%description%":"<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is seeking <strong>Project-Based Geologists<\/strong> to support our client's mining operations. This opportunity is well suited for geologists with hands-on experience in geologic mapping, core logging, sampling, and geological data management.<\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;line-height:1.5;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);\">T<\/span>he Geologist will support day-to-day geology activities, including ore routing and tracking, geological mapping, sampling, data entry and validation, and core and RC chip logging. Additional duties may be assigned based on operational needs.<\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;line-height:1.5;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform ore routing and tracking activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct geological mapping and sampling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Complete core logging and RC chip logging.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Enter, review, and validate geological data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain accurate and organized geological records.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support site geology activities and work under the direction of a Senior Geologist.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform other duties as assigned based on operational requirements.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;line-height:1.5;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Bachelor of Science in Geology required.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous geological mapping experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous core logging experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous data entry experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with databases, mapping software, and 3D modeling software is preferred but not required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work effectively within the assigned rotational schedule and in a site-based geology environment.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;line-height:1.5;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Project Details<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Project Duration:<\/strong> Approximately 1 year with possibility of direct hire.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Schedule:<\/strong> 8\/6, 4\/3 rotation.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Authorization<\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;line-height:1.5;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">About Turner Staffing Group<\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group provides workforce solutions for organizations across the mining and heavy industrial sectors. This project-based opportunity offers the chance to apply hands-on geology experience in an active mining environment while working alongside experienced industry professionals.<\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;line-height:1.5;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is an equal opportunity employer. Employment decisions are made without regard to legally protected characteristics in accordance with applicable law.<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/5451e675bb7a-geologist","%breezy_id%":"5451e675bb7a","%breezy_friendly_id%":"5451e675bb7a-geologist","%breezy_created_date%":"2026-08-25T12:44:54.200Z","%breezy_updated_date%":"2026-08-25T12:44:56.230Z","%_wpgmp_location_city%":"Carlin","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Carlin, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.7138067","%_wpgmp_metabox_longitude%":"-116.1039663","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"701"}},"id":3971,"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    Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-9\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-9\/","zoom":19,"extra_fields":{"post_excerpt":"Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Machine:<\/strong> CAT 352 (Mass Excavation Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Move Massive Dirt \u2013 Power Large-Scale Site Development!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a heavy-equipment professional who knows how to move dirt fast and keep haul trucks moving smoothly? We are hiring a <strong>Mass Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you\u2019ll take command of a high-production <strong>CAT 352 (Mass Excavation Configuration)<\/strong> to tackle heavy bulk cuts and fills, construct haul roads and building pads, and work alongside underground utility teams on major civil projects.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>High-Volume Dirt Production:<\/strong> Masterfully operate a <strong>CAT 352 Mass Excavation Excavator<\/strong> for bulk earthmoving, heavy cut\/fill operations, and site clearing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Rapid Truck Loading:<\/strong> Load off-road and highway haul trucks safely, evenly, and rapidly to keep production cycle times at peak efficiency.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Site Infrastructure:<\/strong> Build smooth haul roads, construct building pads, and shape mass site contours to exact project plan specifications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Underground Utility Support:<\/strong> Perform deep bulk excavations and ground prep to support underground utility installation crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Maintenance &amp; Daily Logging:<\/strong> Complete required <strong>daily equipment logs<\/strong>, conduct daily walkarounds, manage fluid levels, grease key points, and report mechanical needs.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on mass earthwork, bulk cut\/fill, and site development projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Site Skills:<\/strong> Proven expertise in rapid truck loading, pad building, and haul road creation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Utility Awareness:<\/strong> Familiarity working around or prepping ground for underground utility infrastructure.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-9\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Machine:<\/strong> CAT 352 (Mass Excavation Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Move Massive Dirt \u2013 Power Large-Scale Site Development!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a heavy-equipment professional who knows how to move dirt fast and keep haul trucks moving smoothly? We are hiring a <strong>Mass Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you\u2019ll take command of a high-production <strong>CAT 352 (Mass Excavation Configuration)<\/strong> to tackle heavy bulk cuts and fills, construct haul roads and building pads, and work alongside underground utility teams on major civil projects.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>High-Volume Dirt Production:<\/strong> Masterfully operate a <strong>CAT 352 Mass Excavation Excavator<\/strong> for bulk earthmoving, heavy cut\/fill operations, and site clearing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Rapid Truck Loading:<\/strong> Load off-road and highway haul trucks safely, evenly, and rapidly to keep production cycle times at peak efficiency.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Site Infrastructure:<\/strong> Build smooth haul roads, construct building pads, and shape mass site contours to exact project plan specifications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Underground Utility Support:<\/strong> Perform deep bulk excavations and ground prep to support underground utility installation crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Maintenance &amp; Daily Logging:<\/strong> Complete required <strong>daily equipment logs<\/strong>, conduct daily walkarounds, manage fluid levels, grease key points, and report mechanical needs.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on mass earthwork, bulk cut\/fill, and site development projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Site Skills:<\/strong> Proven expertise in rapid truck loading, pad building, and haul road creation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Utility Awareness:<\/strong> Familiarity working around or prepping ground for underground utility infrastructure.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ca1c21d79621-excavator-operator","%breezy_id%":"ca1c21d79621","%breezy_friendly_id%":"ca1c21d79621-excavator-operator","%breezy_created_date%":"2026-08-20T19:54:55.827Z","%breezy_updated_date%":"2026-08-20T19:54:57.980Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"691"}},"id":3961,"infowindow_disable":false},{"source":"post","title":"Lead Pipe Layer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Lead Pipe Layer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Team Lead Pipe Layer \u2013 Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lead-pipe-layer-2\/\" name=\"Lead Pipe Layer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/lead-pipe-layer-2\/","zoom":19,"extra_fields":{"post_excerpt":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Lead Pipe Layer","post_link":"https:\/\/turnerstaffing.com\/position\/lead-pipe-layer-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/e90d82c412b5-lead-pipe-layer","%breezy_id%":"e90d82c412b5","%breezy_friendly_id%":"e90d82c412b5-lead-pipe-layer","%breezy_created_date%":"2026-08-20T19:57:51.470Z","%breezy_updated_date%":"2026-08-20T19:57:53.651Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"692"}},"id":3962,"infowindow_disable":false},{"source":"post","title":"Project Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Lead \u2013 Site Development &amp; Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-lead-3\/\" name=\"Project Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Lead \u2013 Site Development &amp; Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-lead-3\/","zoom":19,"extra_fields":{"post_excerpt":"Project Lead \u2013 Site Development &amp; Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Project Lead \u2013 Site Development &amp; Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Software System:<\/strong> HeavyJob<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Drive Projects. Direct Crews. Master the Dirt &amp; Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you an experienced civil construction leader who knows how to run a jobsite with precision and accountability? We are hiring a <strong>Project Lead<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you will serve as the operational anchor for site development and underground utility projects\u2014managing budgets, schedules, subcontractors, and municipal inspectors in <strong>HeavyJob<\/strong>, while retaining the hands-on skill to operate heavy equipment when the job demands it.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Multi-Crew Leadership:<\/strong> Schedule, direct, and mentor multiple field crews across site prep, bulk earthmoving, and underground utility installations (storm, sanitary, water).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Budget &amp; Schedule Accountability:<\/strong> Manage daily project costs and schedules, optimize labor and machine utilization, and track production in <strong>HeavyJob<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Subcontractor &amp; Inspector Coordination:<\/strong> Coordinate subcontractor workflows and build working relationships with municipal inspectors to secure project sign-offs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Hands-On Field Operations:<\/strong> Lead from the front by operating heavy equipment when needed\u2014including excavators, dozers, loaders, haul trucks, and pipelaying equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Safety &amp; Daily Reporting:<\/strong> Enforce OSHA safety standards, track daily logs and job yields, and maintain site compliance.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>5+ years<\/strong> in site development and underground utility construction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Leadership Track Record:<\/strong> <strong>2\u20133 years<\/strong> of experience running complete civil projects and directing multiple crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Software &amp; Equipment Skills:<\/strong> Hands-on proficiency using <strong>HeavyJob<\/strong>; practical ability to operate dozers, loaders, excavators, dump trucks, and pipelaying gear.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (<strong>OSHA 30 preferred<\/strong>)&nbsp;and <strong>Trench &amp; Excavation Competent Person Certification<\/strong> (Preferred)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Project Lead","post_link":"https:\/\/turnerstaffing.com\/position\/project-lead-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Project Lead \u2013 Site Development &amp; Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Software System:<\/strong> HeavyJob<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Drive Projects. Direct Crews. Master the Dirt &amp; Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you an experienced civil construction leader who knows how to run a jobsite with precision and accountability? We are hiring a <strong>Project Lead<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you will serve as the operational anchor for site development and underground utility projects\u2014managing budgets, schedules, subcontractors, and municipal inspectors in <strong>HeavyJob<\/strong>, while retaining the hands-on skill to operate heavy equipment when the job demands it.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Multi-Crew Leadership:<\/strong> Schedule, direct, and mentor multiple field crews across site prep, bulk earthmoving, and underground utility installations (storm, sanitary, water).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Budget &amp; Schedule Accountability:<\/strong> Manage daily project costs and schedules, optimize labor and machine utilization, and track production in <strong>HeavyJob<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Subcontractor &amp; Inspector Coordination:<\/strong> Coordinate subcontractor workflows and build working relationships with municipal inspectors to secure project sign-offs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Hands-On Field Operations:<\/strong> Lead from the front by operating heavy equipment when needed\u2014including excavators, dozers, loaders, haul trucks, and pipelaying equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Safety &amp; Daily Reporting:<\/strong> Enforce OSHA safety standards, track daily logs and job yields, and maintain site compliance.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>5+ years<\/strong> in site development and underground utility construction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Leadership Track Record:<\/strong> <strong>2\u20133 years<\/strong> of experience running complete civil projects and directing multiple crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Software &amp; Equipment Skills:<\/strong> Hands-on proficiency using <strong>HeavyJob<\/strong>; practical ability to operate dozers, loaders, excavators, dump trucks, and pipelaying gear.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (<strong>OSHA 30 preferred<\/strong>)&nbsp;and <strong>Trench &amp; Excavation Competent Person Certification<\/strong> (Preferred)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/6f9f38542032-project-lead","%breezy_id%":"6f9f38542032","%breezy_friendly_id%":"6f9f38542032-project-lead","%breezy_created_date%":"2026-08-20T20:00:11.228Z","%breezy_updated_date%":"2026-08-20T20:00:13.849Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"693"}},"id":3963,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Haul Truck Driver \u2013 Heavy Equipment Operator Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator\/\" name=\"Haul Truck Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Haul Truck Driver \u2013 Heavy Equipment Operator Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Haul Truck Driver \u2013 Heavy Equipment Operator Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Haul Truck Driver \u2013 Heavy Equipment Operator<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Fleet:<\/strong> CAT 730 \/ CAT 740 Articulated Haul Trucks<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Take the Wheel of Powerful Machinery in Front Royal!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled operator who takes pride in driving heavy iron and keeping civil jobsites moving? We are hiring a dependable, safety-focused <strong>Haul Truck Driver<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">You will primarily pilot <strong>CAT 730 and 740 haul trucks<\/strong> on active underground utility projects, with opportunities to operate secondary support machinery like skid steers and small wheel loaders.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Haul Truck Operations:<\/strong> Safely operate <strong>CAT 730 and 740 articulated haul trucks<\/strong> to haul soil, aggregate, backfill, and rock across underground utility construction sites.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Versatile Equipment Support:<\/strong> Occasionally operate support equipment such as <strong>skid steers and small wheel loaders<\/strong> for site staging, backfilling, and material movement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Pre\/Post-Trip Inspections:<\/strong> Perform daily pre-trip and post-trip equipment safety checks (fluids, hydraulics, tires, lights) to ensure machine reliability.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Logging:<\/strong> Accurately complete daily logs, maintenance sheets, and material load tallies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Jobsite Collaboration:<\/strong> Coordinate closely with site superintendents, excavator operators, and pipe crews for efficient site flow and safety.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>2+ years of experience preferred<\/strong> operating articulated haul trucks (CAT 730\/740 or similar civil earthmoving equipment).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Versatility:<\/strong> Ability or willingness to occasionally jump into skid steers and small wheel loaders when needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> OSHA 10 preferred and a valid drivers license. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Utility Site Knowledge:<\/strong> Familiarity with civil site earthmoving and underground utility construction environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Reliability:<\/strong> Strong commitment to daily pre\/post-trip safety checks, daily logging, and punctual attendance.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Haul Truck Operator","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Haul Truck Driver \u2013 Heavy Equipment Operator<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Fleet:<\/strong> CAT 730 \/ CAT 740 Articulated Haul Trucks<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Take the Wheel of Powerful Machinery in Front Royal!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled operator who takes pride in driving heavy iron and keeping civil jobsites moving? We are hiring a dependable, safety-focused <strong>Haul Truck Driver<\/strong> for a <strong>direct placement<\/strong> role in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">You will primarily pilot <strong>CAT 730 and 740 haul trucks<\/strong> on active underground utility projects, with opportunities to operate secondary support machinery like skid steers and small wheel loaders.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Haul Truck Operations:<\/strong> Safely operate <strong>CAT 730 and 740 articulated haul trucks<\/strong> to haul soil, aggregate, backfill, and rock across underground utility construction sites.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Versatile Equipment Support:<\/strong> Occasionally operate support equipment such as <strong>skid steers and small wheel loaders<\/strong> for site staging, backfilling, and material movement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Pre\/Post-Trip Inspections:<\/strong> Perform daily pre-trip and post-trip equipment safety checks (fluids, hydraulics, tires, lights) to ensure machine reliability.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Logging:<\/strong> Accurately complete daily logs, maintenance sheets, and material load tallies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Jobsite Collaboration:<\/strong> Coordinate closely with site superintendents, excavator operators, and pipe crews for efficient site flow and safety.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>2+ years of experience preferred<\/strong> operating articulated haul trucks (CAT 730\/740 or similar civil earthmoving equipment).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Versatility:<\/strong> Ability or willingness to occasionally jump into skid steers and small wheel loaders when needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> OSHA 10 preferred and a valid drivers license. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Utility Site Knowledge:<\/strong> Familiarity with civil site earthmoving and underground utility construction environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Reliability:<\/strong> Strong commitment to daily pre\/post-trip safety checks, daily logging, and punctual attendance.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/67dd403a967a-haul-truck-operator","%breezy_id%":"67dd403a967a","%breezy_friendly_id%":"67dd403a967a-haul-truck-operator","%breezy_created_date%":"2026-08-20T20:10:09.653Z","%breezy_updated_date%":"2026-08-20T20:10:14.667Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"694"}},"id":3964,"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    Excavator Operator &#8211; Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT 320 \u2013&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-7\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Excavator Operator &#8211; Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT 320 \u2013&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-7\/","zoom":19,"extra_fields":{"post_excerpt":"Excavator Operator &#8211; Underground Utilities Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT 320 \u2013&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Excavator Operator - Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Fleet:<\/strong> CAT 320 \u2013 CAT 336 Excavators<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>About the Role<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled heavy equipment operator looking for a <strong>permanent, direct-hire opportunity<\/strong> with steady work and modern iron? We are hiring an experienced <strong>Excavator Operator<\/strong> to join our site utility team.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you\u2019ll be a vital part of our underground utility crew, operating heavy production excavators (<strong>CAT 320 to CAT 336<\/strong>) to dig trenches, place pipe, and manage material on site. You will work directly under the guidance of our Team Lead to execute precise, safe, and efficient utility installations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Precision Excavation:<\/strong> Dig trenches to exact grade and depth for underground utility systems (water, sewer, storm, etc.) in dynamic soil conditions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Trench &amp; Pipe Operations:<\/strong> Lift, move, and position heavy pipe, trench boxes, and utility structures directly into the trench with precision and care.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Controlled Backfill:<\/strong> Place and compact backfill material in controlled lifts to ensure proper structural integrity and meet compaction specifications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Cross-Equipment Operation:<\/strong> Occasionally step into auxiliary machines, such as <strong>CAT 930 rubber-tired loaders<\/strong> or <strong>CAT 963 track loaders<\/strong>, to assist with site prep, material management, and stock piling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Maintenance &amp; Logs:<\/strong> Perform standard pre-shift\/post-shift inspections and accurately complete daily equipment logs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Jobsite Safety:<\/strong> Maintain a strict safety-first mindset around open excavations, existing utility lines, and ground personnel.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> 2 years of heavy excavator operation required (<strong>3 to 5+ years preferred<\/strong>).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Underground Utility Focus:<\/strong> Direct experience working around underground utilities is required; <strong>pipelaying experience is highly preferred<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Fleet Familiarity:<\/strong> Demonstrated competency operating CAT 320 to 336 class excavators (or equivalent mid-to-heavy machines).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Versatility:<\/strong> Willingness to operate support machinery (CAT 930 loader \/ CAT 963 track loader) when needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Reliability &amp; Teamwork:<\/strong> Strong work ethic, reliable attendance, and ability to collaborate effectively with field team members and the Team Lead.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Excavator Operator - Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Fleet:<\/strong> CAT 320 \u2013 CAT 336 Excavators<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>About the Role<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled heavy equipment operator looking for a <strong>permanent, direct-hire opportunity<\/strong> with steady work and modern iron? We are hiring an experienced <strong>Excavator Operator<\/strong> to join our site utility team.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you\u2019ll be a vital part of our underground utility crew, operating heavy production excavators (<strong>CAT 320 to CAT 336<\/strong>) to dig trenches, place pipe, and manage material on site. You will work directly under the guidance of our Team Lead to execute precise, safe, and efficient utility installations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Precision Excavation:<\/strong> Dig trenches to exact grade and depth for underground utility systems (water, sewer, storm, etc.) in dynamic soil conditions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Trench &amp; Pipe Operations:<\/strong> Lift, move, and position heavy pipe, trench boxes, and utility structures directly into the trench with precision and care.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Controlled Backfill:<\/strong> Place and compact backfill material in controlled lifts to ensure proper structural integrity and meet compaction specifications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Cross-Equipment Operation:<\/strong> Occasionally step into auxiliary machines, such as <strong>CAT 930 rubber-tired loaders<\/strong> or <strong>CAT 963 track loaders<\/strong>, to assist with site prep, material management, and stock piling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Maintenance &amp; Logs:<\/strong> Perform standard pre-shift\/post-shift inspections and accurately complete daily equipment logs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Jobsite Safety:<\/strong> Maintain a strict safety-first mindset around open excavations, existing utility lines, and ground personnel.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> 2 years of heavy excavator operation required (<strong>3 to 5+ years preferred<\/strong>).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Underground Utility Focus:<\/strong> Direct experience working around underground utilities is required; <strong>pipelaying experience is highly preferred<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Fleet Familiarity:<\/strong> Demonstrated competency operating CAT 320 to 336 class excavators (or equivalent mid-to-heavy machines).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Versatility:<\/strong> Willingness to operate support machinery (CAT 930 loader \/ CAT 963 track loader) when needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Reliability &amp; Teamwork:<\/strong> Strong work ethic, reliable attendance, and ability to collaborate effectively with field team members and the Team Lead.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/82a6d923e269-excavator-operator","%breezy_id%":"82a6d923e269","%breezy_friendly_id%":"82a6d923e269-excavator-operator","%breezy_created_date%":"2026-08-20T19:40:47.541Z","%breezy_updated_date%":"2026-08-20T19:40:49.490Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"686"}},"id":3956,"infowindow_disable":false},{"source":"post","title":"Dozer Operator (Team Lead)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator (Team Lead)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    GPS Dozer Operator \/ Team Lead Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead-2\/\" name=\"Dozer Operator (Team Lead)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"GPS Dozer Operator \/ Team Lead Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead-2\/","zoom":19,"extra_fields":{"post_excerpt":"GPS Dozer Operator \/ Team Lead Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><u>GPS Dozer Operator \/ Team Lead<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Fleet:<\/strong> CAT D3, D5\/DK, D6K, D6 XE, D8 Dozers<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Reports To:<\/strong> Project Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>About the Role<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you an experienced dozer operator who knows <strong>Trimble 3D GPS<\/strong> inside and out and thrives in a leadership role? We are seeking a <strong>GPS Dozer Operator \/ Team Lead<\/strong> for a <strong>direct placement position<\/strong> with one of our top civil earthwork clients.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you\u2019ll lead from the cab and on the ground\u2014running high-production Caterpillar iron, setting up and verifying 3D site models, and directing field crews to complete mass earthwork projects on time and on grade.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Precision Grading &amp; Earthmoving:<\/strong> Operate a full spectrum of CAT dozers (<strong>D3, D6K, D5\/DK, D6 XE Electric Drive, and D8<\/strong>) for mass excavation, fine grading, subgrade preparation, and site setup.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Trimble GPS &amp; Model Verification:<\/strong> Set up Trimble GPS base stations\/rovers, lay out grade stakes, verify digital terrain models against plans, and troubleshoot grade adjustments on the fly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Leadership &amp; Coordination:<\/strong> Serve as a working Team Lead\u2014directing site personnel, delegating daily tasks, keeping work moving efficiently, and reporting progress to the Project Lead.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Production Tracking &amp; Daily Logs:<\/strong> Complete daily equipment logs and track site production quantities, equipment hours, and delays using <strong>HeavyJob<\/strong> or daily log software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Auxiliary Equipment Operation:<\/strong> Step into support iron when needed, including skid steers, rollers, and track loaders to keep operations fluid.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Jobsite Safety:<\/strong> Lead daily safety briefings (toolbox talks) and enforce zero-compromise safety protocols around heavy machinery and active earthwork zones.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> 4+ years of heavy dozer operation required (preferably focused on civil earthwork and site development).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>GPS Expertise:<\/strong> 2+ years of hands-on experience utilizing <strong>Trimble GPS-guided systems<\/strong>, including model verification and grade layout.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Leadership Background:<\/strong> 2+ years of experience leading site crews and managing daily field workflows.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required (willingness to obtain OSHA 30 is required).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Reporting &amp; Tech Proficiency:<\/strong> Familiarity with <strong>HeavyJob<\/strong> or electronic daily project logging tools.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Machine Versatility:<\/strong> Competency across small-to-large dozers (CAT D3 to D8) and basic support iron (skid steers\/rollers).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Dozer Operator (Team Lead)","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><u>GPS Dozer Operator \/ Team Lead<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Fleet:<\/strong> CAT D3, D5\/DK, D6K, D6 XE, D8 Dozers<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Reports To:<\/strong> Project Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>About the Role<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you an experienced dozer operator who knows <strong>Trimble 3D GPS<\/strong> inside and out and thrives in a leadership role? We are seeking a <strong>GPS Dozer Operator \/ Team Lead<\/strong> for a <strong>direct placement position<\/strong> with one of our top civil earthwork clients.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you\u2019ll lead from the cab and on the ground\u2014running high-production Caterpillar iron, setting up and verifying 3D site models, and directing field crews to complete mass earthwork projects on time and on grade.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Precision Grading &amp; Earthmoving:<\/strong> Operate a full spectrum of CAT dozers (<strong>D3, D6K, D5\/DK, D6 XE Electric Drive, and D8<\/strong>) for mass excavation, fine grading, subgrade preparation, and site setup.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Trimble GPS &amp; Model Verification:<\/strong> Set up Trimble GPS base stations\/rovers, lay out grade stakes, verify digital terrain models against plans, and troubleshoot grade adjustments on the fly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Leadership &amp; Coordination:<\/strong> Serve as a working Team Lead\u2014directing site personnel, delegating daily tasks, keeping work moving efficiently, and reporting progress to the Project Lead.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Production Tracking &amp; Daily Logs:<\/strong> Complete daily equipment logs and track site production quantities, equipment hours, and delays using <strong>HeavyJob<\/strong> or daily log software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Auxiliary Equipment Operation:<\/strong> Step into support iron when needed, including skid steers, rollers, and track loaders to keep operations fluid.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Jobsite Safety:<\/strong> Lead daily safety briefings (toolbox talks) and enforce zero-compromise safety protocols around heavy machinery and active earthwork zones.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> 4+ years of heavy dozer operation required (preferably focused on civil earthwork and site development).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>GPS Expertise:<\/strong> 2+ years of hands-on experience utilizing <strong>Trimble GPS-guided systems<\/strong>, including model verification and grade layout.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Leadership Background:<\/strong> 2+ years of experience leading site crews and managing daily field workflows.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required (willingness to obtain OSHA 30 is required).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Reporting &amp; Tech Proficiency:<\/strong> Familiarity with <strong>HeavyJob<\/strong> or electronic daily project logging tools.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Machine Versatility:<\/strong> Competency across small-to-large dozers (CAT D3 to D8) and basic support iron (skid steers\/rollers).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/8cdc63f47be6-dozer-operator-team-lead","%breezy_id%":"8cdc63f47be6","%breezy_friendly_id%":"8cdc63f47be6-dozer-operator-team-lead","%breezy_created_date%":"2026-08-20T19:43:21.250Z","%breezy_updated_date%":"2026-08-20T19:43:23.200Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"687"}},"id":3957,"infowindow_disable":false},{"source":"post","title":"General Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-2\/\" name=\"General Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-2\/","zoom":19,"extra_fields":{"post_excerpt":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Build Your Career in Heavy Construction<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Your Development Path<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p><ol style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li>\n<\/ol><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"General Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Build Your Career in Heavy Construction<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Your Development Path<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>:<\/p><ol style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs!<\/li>\n<\/ol><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/e6af0c871842-general-construction-laborer","%breezy_id%":"e6af0c871842","%breezy_friendly_id%":"e6af0c871842-general-construction-laborer","%breezy_created_date%":"2026-08-20T19:46:33.720Z","%breezy_updated_date%":"2026-08-20T19:46:35.765Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"688"}},"id":3958,"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    Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Front Royal, VA Position Type: Direct Placement (Full-Time,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-3\/\" name=\"Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Front Royal, VA Position Type: Direct Placement (Full-Time,&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-3\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Front Royal, VA Position Type: Direct Placement (Full-Time,&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/c0f671c0c0b8-loader-operator","%breezy_id%":"c0f671c0c0b8","%breezy_friendly_id%":"c0f671c0c0b8-loader-operator","%breezy_created_date%":"2026-08-20T19:49:26.371Z","%breezy_updated_date%":"2026-08-20T19:49:28.682Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"689"}},"id":3959,"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    Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-8\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","address":"Front Royal, VA, USA","location":{"lat":"38.9181671","city":"Front Royal","state":"VA","country":"United States","lng":"-78.1944446","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-8\/","zoom":19,"extra_fields":{"post_excerpt":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Front Royal, VA Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-8\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Front Royal","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Front Royal, VA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Front Royal, VA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Front Royal, VA<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/aa01e2912282-excavator-operator","%breezy_id%":"aa01e2912282","%breezy_friendly_id%":"aa01e2912282-excavator-operator","%breezy_created_date%":"2026-08-20T19:52:20.667Z","%breezy_updated_date%":"2026-08-20T19:52:22.884Z","%_wpgmp_location_city%":"Front Royal","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Front Royal, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9181671","%_wpgmp_metabox_longitude%":"-78.1944446","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"690"}},"id":3960,"infowindow_disable":false},{"source":"post","title":"General Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-construction-laborer\/\" name=\"General Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;","address":"Charles Town, WV, USA","location":{"lat":"39.2889903","city":"Charles Town","state":"WV","country":"United States","lng":"-77.8597175","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer\/","zoom":19,"extra_fields":{"post_excerpt":"General Laborer \u2013 Underground Utilities &amp; Heavy Civil Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Build Your&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Build Your Career in Heavy Construction<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Your Development Path<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>: <\/p><ol style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs! <\/li>\n<\/ol><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Driver's License:<\/strong> Valid Driver's License required. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.) <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"General Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-construction-laborer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charles Town","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Charles Town, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>General Laborer \u2013 Underground Utilities &amp; Heavy Civil<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Build Your Career in Heavy Construction<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you hard-working, reliable, and looking for a real career path instead of just another job? We are hiring a <strong>General Laborer<\/strong> for heavy civil and utility construction projects in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">No prior heavy civil experience is required. If you bring a strong work ethic, rock-solid reliability, and a focus on safety, we will train you on the tools, trade skills, and machinery you need to build a high-paying, long-term career. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Your Development Path<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We don't want you to stay a laborer forever. We offer a <strong>clear, structured path for advancement<\/strong>: <\/p><ol style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>General Laborer:<\/strong> Master hands-on tools, safety protocols, compaction, and pipe laser setup. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Pipe Layer:<\/strong> Learn to lay, set, and secure underground utility systems. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Operator:<\/strong> Earn your seat in excavator, loader, and dozer cabs! <\/li>\n<\/ol><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Hands-On Site Work:<\/strong> Work alongside experienced tradespeople using hand and power tools for trenching, utility setup, and site preparation. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Compaction &amp; Grade Tools:<\/strong> Operate compaction equipment (rammers, plate compactors, rollers) and set up pipe lasers for proper grade alignment. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Machine Operation:<\/strong> Learn to operate small pieces of construction equipment as you complete site training. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Safety &amp; Support:<\/strong> Assist with staging materials, maintaining trench safety, and ensuring a safe, efficient jobsite. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Driver's License:<\/strong> Valid Driver's License required. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> OSHA 10 certification is preferred, but a <strong>willingness to obtain it upon hire is required<\/strong>. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>Entry level!<\/strong> No prior heavy civil experience required. (Prior general construction or pipe laying experience is a plus.) <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Key Traits:<\/strong> Extreme reliability, punctuality, strong safety awareness, and an eagerness to learn new skills. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/94ccc0643cc8-general-construction-laborer","%breezy_id%":"94ccc0643cc8","%breezy_friendly_id%":"94ccc0643cc8-general-construction-laborer","%breezy_created_date%":"2026-08-20T16:06:46.006Z","%breezy_updated_date%":"2026-08-20T16:06:48.009Z","%_wpgmp_location_city%":"Charles Town","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charles Town, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2889903","%_wpgmp_metabox_longitude%":"-77.8597175","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"680"}},"id":3950,"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    Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Charles Town, WV Position Type: Direct Placement (Full-Time,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-2\/\" name=\"Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Charles Town, WV Position Type: Direct Placement (Full-Time,&hellip;","address":"Charles Town, WV, USA","location":{"lat":"39.2889903","city":"Charles Town","state":"WV","country":"United States","lng":"-77.8597175","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963) Location: Charles Town, WV Position Type: Direct Placement (Full-Time,&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Charles Town, WV<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charles Town","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Charles Town, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Heavy Equipment Operator \u2013 Loader Specialist (CAT 930 &amp; CAT 963)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Fleet:<\/strong> CAT 930 Rubber-Tire Loaders &amp; CAT 963 Track Loaders<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Keep the Jobsite Moving \u2013 Master Wheels &amp; Tracks!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled heavy equipment operator who knows how to keep production rolling? We are hiring a <strong>Loader Operator<\/strong> for direct placement on high-activity civil construction and earthwork sites in <strong>Charles Town, WV<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you\u2019ll be at the center of site activity\u2014operating both agile rubber-tired loaders (<strong>CAT 930<\/strong>) and heavy-duty track loaders (<strong>CAT 963<\/strong>) to handle material transport, loading trucks, feeding utility crews, and rough grading.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Dual-Machine Operation:<\/strong> Efficiently operate <strong>CAT 930 wheel loaders<\/strong> for fast material transport and <strong>CAT 963 track loaders<\/strong> for tough terrain, heavy digging, and rough grade work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Material &amp; Stockpile Management:<\/strong> Load haul trucks, build and manage stockpiles, move pipe\/aggregates, and supply active utility and earthwork crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Site Preparation:<\/strong> Assist with backfilling, clearing site debris, smoothing haul roads, and setting up work zones.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Inspections:<\/strong> Perform pre-trip and post-trip fluid checks, grease daily wear points, and report maintenance needs to keep iron running smoothly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Safety &amp; Communication:<\/strong> Work closely with site leads, truck drivers, and ground crews to maintain seamless, zero-incident site operations.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> 2+ years of experience operating heavy wheel loaders, track loaders, or heavy earthmoving equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Driver's License:<\/strong> Valid Driver's License required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Knowledge:<\/strong> Hands-on experience with CAT equipment (specifically CAT 930 wheel loaders and\/or CAT 963 track loaders preferred).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Work Ethic &amp; Safety:<\/strong> Strong jobsite hazard awareness, excellent communication, punctuality, and a strong work ethic.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/642470b328bb-loader-operator","%breezy_id%":"642470b328bb","%breezy_friendly_id%":"642470b328bb-loader-operator","%breezy_created_date%":"2026-08-20T17:47:04.719Z","%breezy_updated_date%":"2026-08-20T17:47:07.002Z","%_wpgmp_location_city%":"Charles Town","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charles Town, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2889903","%_wpgmp_metabox_longitude%":"-77.8597175","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"681"}},"id":3951,"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    Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-5\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","address":"Charles Town, WV, USA","location":{"lat":"39.2889903","city":"Charles Town","state":"WV","country":"United States","lng":"-77.8597175","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-5\/","zoom":19,"extra_fields":{"post_excerpt":"Mainline Excavator Operator \u2013 Underground Utilities (CAT 340) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm). <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charles Town","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Charles Town, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Mainline Excavator Operator \u2013 Underground Utilities (CAT 340)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Machine:<\/strong> CAT 340 (Mainline Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Lead the Dig \u2013 Precision Deep Utility Operations!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you an expert stick-hand who knows how to keep a pipe crew moving safely and production high? We are hiring a <strong>Mainline Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this key role, you\u2019ll take the controls of a <strong>CAT 340<\/strong> to dig deep mainlines to exact line and grade, set and advance heavy trench boxes, place structures, and protect the crew working in the ditch below. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Precision Mainline Trenching:<\/strong> Operate a <strong>CAT 340 (Mainline Configuration)<\/strong> to dig trenches to tight line and grade tolerances for underground utility systems (water, sewer, storm). <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Shored Trenching &amp; Structure Setting:<\/strong> Expertly set, align, and advance heavy trench boxes\/shoring while picking and setting pipe sections and utility structures. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Safety Leadership:<\/strong> Work directly over and in constant rhythm with the pipe crew inside open trenches, maintaining top-tier situational awareness. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Logging &amp; Maintenance:<\/strong> Complete required <strong>daily equipment logs<\/strong>, perform pre- and post-trip walkarounds, check fluid levels, and report maintenance needs. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Team Collaboration:<\/strong> Work in close partnership with your <strong>Team Lead<\/strong> and grade checkers to safely meet daily production targets. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on underground utility and mainline pipelaying projects. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Pipelaying Expertise:<\/strong> Proven background trenching to line and grade, setting structures, and managing deep utility excavations. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Technical Skills:<\/strong> Expert ability to set, advance, and step trench boxes safely around working ground crews. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/5dcf8d6e7f84-excavator-operator","%breezy_id%":"5dcf8d6e7f84","%breezy_friendly_id%":"5dcf8d6e7f84-excavator-operator","%breezy_created_date%":"2026-08-20T17:58:26.784Z","%breezy_updated_date%":"2026-08-20T17:58:28.678Z","%_wpgmp_location_city%":"Charles Town","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charles Town, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2889903","%_wpgmp_metabox_longitude%":"-77.8597175","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"682"}},"id":3952,"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    Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","address":"Charles Town, WV, USA","location":{"lat":"39.2889903","city":"Charles Town","state":"WV","country":"United States","lng":"-77.8597175","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352) Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Machine:&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Machine:<\/strong> CAT 352 (Mass Excavation Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Move Massive Dirt \u2013 Power Large-Scale Site Development!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a heavy-equipment professional who knows how to move dirt fast and keep haul trucks moving smoothly? We are hiring a <strong>Mass Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you\u2019ll take command of a high-production <strong>CAT 352 (Mass Excavation Configuration)<\/strong> to tackle heavy bulk cuts and fills, construct haul roads and building pads, and work alongside underground utility teams on major civil projects. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>High-Volume Dirt Production:<\/strong> Masterfully operate a <strong>CAT 352 Mass Excavation Excavator<\/strong> for bulk earthmoving, heavy cut\/fill operations, and site clearing. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Rapid Truck Loading:<\/strong> Load off-road and highway haul trucks safely, evenly, and rapidly to keep production cycle times at peak efficiency. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Site Infrastructure:<\/strong> Build smooth haul roads, construct building pads, and shape mass site contours to exact project plan specifications. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Underground Utility Support:<\/strong> Perform deep bulk excavations and ground prep to support underground utility installation crews. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Maintenance &amp; Daily Logging:<\/strong> Complete required <strong>daily equipment logs<\/strong>, conduct daily walkarounds, manage fluid levels, grease key points, and report mechanical needs. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on mass earthwork, bulk cut\/fill, and site development projects. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Site Skills:<\/strong> Proven expertise in rapid truck loading, pad building, and haul road creation. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Utility Awareness:<\/strong> Familiarity working around or prepping ground for underground utility infrastructure. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charles Town","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Charles Town, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Mass Excavator Operator \u2013 Heavy Earthmoving (CAT 352)<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Machine:<\/strong> CAT 352 (Mass Excavation Configuration)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Move Massive Dirt \u2013 Power Large-Scale Site Development!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a heavy-equipment professional who knows how to move dirt fast and keep haul trucks moving smoothly? We are hiring a <strong>Mass Excavator Operator<\/strong> for a <strong>direct placement<\/strong> opportunity in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you\u2019ll take command of a high-production <strong>CAT 352 (Mass Excavation Configuration)<\/strong> to tackle heavy bulk cuts and fills, construct haul roads and building pads, and work alongside underground utility teams on major civil projects. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>High-Volume Dirt Production:<\/strong> Masterfully operate a <strong>CAT 352 Mass Excavation Excavator<\/strong> for bulk earthmoving, heavy cut\/fill operations, and site clearing. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Rapid Truck Loading:<\/strong> Load off-road and highway haul trucks safely, evenly, and rapidly to keep production cycle times at peak efficiency. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Site Infrastructure:<\/strong> Build smooth haul roads, construct building pads, and shape mass site contours to exact project plan specifications. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Underground Utility Support:<\/strong> Perform deep bulk excavations and ground prep to support underground utility installation crews. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Maintenance &amp; Daily Logging:<\/strong> Complete required <strong>daily equipment logs<\/strong>, conduct daily walkarounds, manage fluid levels, grease key points, and report mechanical needs. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> Minimum <strong>3 years of hands-on experience<\/strong> operating heavy excavators on mass earthwork, bulk cut\/fill, and site development projects. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Site Skills:<\/strong> Proven expertise in rapid truck loading, pad building, and haul road creation. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications &amp; Compliance:<\/strong> <strong>Active OSHA 10 certification<\/strong> and a <strong>valid Driver's License<\/strong> are required. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Utility Awareness:<\/strong> Familiarity working around or prepping ground for underground utility infrastructure. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/57cf74639742-excavator-operator","%breezy_id%":"57cf74639742","%breezy_friendly_id%":"57cf74639742-excavator-operator","%breezy_created_date%":"2026-08-20T18:09:20.106Z","%breezy_updated_date%":"2026-08-20T18:09:22.351Z","%_wpgmp_location_city%":"Charles Town","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charles Town, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2889903","%_wpgmp_metabox_longitude%":"-77.8597175","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"683"}},"id":3953,"infowindow_disable":false},{"source":"post","title":"Lead Pipe Layer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Lead Pipe Layer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Team Lead Pipe Layer \u2013 Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lead-pipe-layer\/\" name=\"Lead Pipe Layer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;","address":"Charles Town, WV, USA","location":{"lat":"39.2889903","city":"Charles Town","state":"WV","country":"United States","lng":"-77.8597175","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/lead-pipe-layer\/","zoom":19,"extra_fields":{"post_excerpt":"Team Lead Pipe Layer \u2013 Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Field Tech: Pipe&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests). <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Lead Pipe Layer","post_link":"https:\/\/turnerstaffing.com\/position\/lead-pipe-layer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charles Town","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Charles Town, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Team Lead Pipe Layer \u2013 Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Field Tech:<\/strong> Pipe Lasers, GPS Rovers, Line Transfer Units<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Lead the Trench \u2013 Set the Standard in Underground Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled utility professional who knows how to lay pipe on grade and lead a crew with authority? We are hiring a <strong>Team Lead Pipe Layer<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this position, you will combine technical grade-setting skills with frontline leadership\u2014reading civil plans, utilizing GPS rovers and pipe lasers, running utility testing, and directing daily site production for water, storm, and sanitary systems. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Leadership &amp; Daily Operations:<\/strong> Lead, mentor, and coordinate a crew of pipe layers and labor personnel to meet production goals safely and efficiently. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Plan Reading &amp; Precision Layout:<\/strong> Interpret civil site plans to establish accurate lines and grades using <strong>pipe lasers, GPS rovers, and line transfer units<\/strong>. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Utility Installation &amp; Testing:<\/strong> Oversee deep underground utility installations (storm, sanitary, water main) and execute required field testing (air, mandrel, or pressure tests). <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Support:<\/strong> Support backfill and material handling by occasionally operating <strong>small wheel loaders and end-dump haul trucks<\/strong> as needed. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Safety &amp; Daily Logs:<\/strong> Maintain strict OSHA trench safety protocols, perform daily site safety inspections, and complete accurate <strong>daily production logs<\/strong>. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>5+ years preferred<\/strong> in underground utility pipe laying, with <strong>2+ years<\/strong> leading crews or acting as a working foreman. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Technical Skills:<\/strong> Proficient in reading civil blueprints, running utility acceptance tests, and operating pipe lasers, line transfer units, and GPS rovers. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Equipment Ability:<\/strong> Hands-on experience operating small loaders and end-dump trucks preferred. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (OSHA 30 preferred) and a <strong>valid Driver's License<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/4afe84ea311e-lead-pipe-layer","%breezy_id%":"4afe84ea311e","%breezy_friendly_id%":"4afe84ea311e-lead-pipe-layer","%breezy_created_date%":"2026-08-20T18:21:58.658Z","%breezy_updated_date%":"2026-08-20T18:22:01.949Z","%_wpgmp_location_city%":"Charles Town","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charles Town, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2889903","%_wpgmp_metabox_longitude%":"-77.8597175","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"684"}},"id":3954,"infowindow_disable":false},{"source":"post","title":"Project Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Lead \u2013 Site Development &amp; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-lead-2\/\" name=\"Project Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Lead \u2013 Site Development &amp; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;","address":"Charles Town, WV, USA","location":{"lat":"39.2889903","city":"Charles Town","state":"WV","country":"United States","lng":"-77.8597175","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-lead-2\/","zoom":19,"extra_fields":{"post_excerpt":"Project Lead \u2013 Site Development &amp; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Software System:&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Project Lead \u2013 Site Development &amp; Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Software System:<\/strong> HeavyJob<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Drive Projects. Direct Crews. Master the Dirt &amp; Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you an experienced civil construction leader who knows how to run a jobsite with precision and accountability? We are hiring a <strong>Project Lead<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you will serve as the operational anchor for site development and underground utility projects\u2014managing budgets, schedules, subcontractors, and municipal inspectors in <strong>HeavyJob<\/strong>, while retaining the hands-on skill to operate heavy equipment when the job demands it. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Multi-Crew Leadership:<\/strong> Schedule, direct, and mentor multiple field crews across site prep, bulk earthmoving, and underground utility installations (storm, sanitary, water). <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Budget &amp; Schedule Accountability:<\/strong> Manage daily project costs and schedules, optimize labor and machine utilization, and track production in <strong>HeavyJob<\/strong>. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Subcontractor &amp; Inspector Coordination:<\/strong> Coordinate subcontractor workflows and build working relationships with municipal inspectors to secure project sign-offs. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Hands-On Field Operations:<\/strong> Lead from the front by operating heavy equipment when needed\u2014including excavators, dozers, loaders, haul trucks, and pipelaying equipment. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Safety &amp; Daily Reporting:<\/strong> Enforce OSHA safety standards, track daily logs and job yields, and maintain site compliance. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> <strong>5+ years<\/strong> in site development and underground utility construction. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Leadership Track Record:<\/strong> <strong>2\u20133 years<\/strong> of experience running complete civil projects and directing multiple crews. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Software &amp; Equipment Skills:<\/strong> Hands-on proficiency using <strong>HeavyJob<\/strong>; practical ability to operate dozers, loaders, excavators, dump trucks, and pipelaying gear. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (<strong>OSHA 30 preferred<\/strong>)&nbsp;and <strong>Trench &amp; Excavation Competent Person Certification<\/strong> (Preferred)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Project Lead","post_link":"https:\/\/turnerstaffing.com\/position\/project-lead-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charles Town","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Charles Town, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Project Lead \u2013 Site Development &amp; Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Software System:<\/strong> HeavyJob<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Drive Projects. Direct Crews. Master the Dirt &amp; Utilities!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you an experienced civil construction leader who knows how to run a jobsite with precision and accountability? We are hiring a <strong>Project Lead<\/strong> for a <strong>direct placement<\/strong> role in <strong>Charles Town, WV<\/strong>. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you will serve as the operational anchor for site development and underground utility projects\u2014managing budgets, schedules, subcontractors, and municipal inspectors in <strong>HeavyJob<\/strong>, while retaining the hands-on skill to operate heavy equipment when the job demands it. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Multi-Crew Leadership:<\/strong> Schedule, direct, and mentor multiple field crews across site prep, bulk earthmoving, and underground utility installations (storm, sanitary, water). <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Budget &amp; Schedule Accountability:<\/strong> Manage daily project costs and schedules, optimize labor and machine utilization, and track production in <strong>HeavyJob<\/strong>. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Subcontractor &amp; Inspector Coordination:<\/strong> Coordinate subcontractor workflows and build working relationships with municipal inspectors to secure project sign-offs. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Hands-On Field Operations:<\/strong> Lead from the front by operating heavy equipment when needed\u2014including excavators, dozers, loaders, haul trucks, and pipelaying equipment. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Safety &amp; Daily Reporting:<\/strong> Enforce OSHA safety standards, track daily logs and job yields, and maintain site compliance. <\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> <strong>5+ years<\/strong> in site development and underground utility construction. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Leadership Track Record:<\/strong> <strong>2\u20133 years<\/strong> of experience running complete civil projects and directing multiple crews. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Software &amp; Equipment Skills:<\/strong> Hands-on proficiency using <strong>HeavyJob<\/strong>; practical ability to operate dozers, loaders, excavators, dump trucks, and pipelaying gear. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> <strong>OSHA 10 required<\/strong> (<strong>OSHA 30 preferred<\/strong>)&nbsp;and <strong>Trench &amp; Excavation Competent Person Certification<\/strong> (Preferred)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/20137ff8f0e1-project-lead","%breezy_id%":"20137ff8f0e1","%breezy_friendly_id%":"20137ff8f0e1-project-lead","%breezy_created_date%":"2026-08-20T18:37:52.893Z","%breezy_updated_date%":"2026-08-20T18:37:54.919Z","%_wpgmp_location_city%":"Charles Town","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charles Town, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2889903","%_wpgmp_metabox_longitude%":"-77.8597175","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"685"}},"id":3955,"infowindow_disable":false},{"source":"post","title":"Administrative Assistant","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Administrative Assistant\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a professional, organized, and service-oriented Administrative Assistant to support operations at a mining project in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/administrative-assistant\/\" name=\"Administrative Assistant\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a professional, organized, and service-oriented Administrative Assistant to support operations at a mining project in&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\/administrative-assistant\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a professional, organized, and service-oriented Administrative Assistant to support operations at a mining project in&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is seeking a professional, organized, and service-oriented <strong>Administrative Assistant<\/strong> to support operations at a mining project in <strong>Elko, Nevada<\/strong>. This is a <strong>full-time, on-site, project-based assignment<\/strong> supporting site leadership and the broader project team.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The Administrative Assistant will provide day-to-day administrative, logistical, reporting, and office support while helping maintain an organized and efficient work environment. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position will work directly for <strong>Turner Staffing Group<\/strong> while supporting our client's mining project.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This opportunity may also be a strong fit for a <strong>current college or university student who is completing their degree<\/strong> and looking to gain professional experience in a project-based environment. Students are encouraged to apply as long as they can consistently work a <strong>full-time daytime schedule of either four 10-hour days or five 8-hour days per week<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The ideal candidate is proactive, detail-oriented, dependable, and comfortable working in a fast-paced environment. <strong>Strong Microsoft Excel skills are essential<\/strong>, including experience with data entry, data manipulation, tracking, and report preparation.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide day-to-day administrative support to site leadership and project personnel.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform accurate and timely data entry and maintain project records, spreadsheets, trackers, and reports.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Use Microsoft Excel to organize, manipulate, track, and report project-related information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prepare and update routine reports, spreadsheets, documents, and presentations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain organized electronic and physical files and documentation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with scheduling meetings, appointments, and project activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate meeting logistics and prepare materials as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support communication and information flow between site personnel, Turner Staffing Group, and project stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with onboarding coordination, employee documentation, and workforce-related administrative tasks as assigned.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support office supply, equipment, and general site office needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with travel, lodging, and other logistical coordination when required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Respond professionally to questions and requests from employees, supervisors, and project personnel.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain confidentiality when handling employee, project, and business information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Help maintain an organized, professional, and welcoming site office.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow applicable site safety requirements, policies, and procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide additional administrative and project support as needed.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous administrative, office, customer service, data entry, project support, or similar experience is preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Current college or university students are encouraged to apply<\/strong>, provided they can meet the full-time daytime work schedule.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Strong Microsoft Excel skills required<\/strong>, including experience with:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Data entry and spreadsheet maintenance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Sorting, filtering, and organizing data<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Data manipulation and cleanup<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Creating and maintaining trackers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preparing reports from spreadsheet data<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Formulas and standard Excel functions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong general computer skills, including Microsoft Office.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Excellent organizational skills and attention to detail.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong written and verbal communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Professional and service-oriented approach.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to manage multiple priorities and meet deadlines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to learn new processes and systems quickly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Dependable and able to maintain discretion with confidential information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work independently while contributing effectively to a team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work <strong>40 hours per week during daytime business\/project hours<\/strong>, on either a <strong>4x10-hour or 5x8-hour schedule<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work <strong>on-site at a mining project near Elko, Nevada<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Mining, construction, industrial, or project-site experience is helpful but <strong>not required<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Who This Role Could Be a Good Fit For<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position could be an excellent opportunity for an <strong>early-career professional or college\/university student nearing completion of their degree<\/strong> who wants practical experience supporting a large-scale industrial project.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>This is not a part-time student position.<\/strong> <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Project-Based Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This is a <strong>full-time, project-based position with Turner Staffing Group<\/strong> supporting a mining client's project near Elko. For the right candidate, there is a <strong>possibility of transitioning to a direct-hire opportunity<\/strong> based on performance, overall fit, client needs, and project requirements. A transition to direct hire is not guaranteed.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">About Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group provides workforce solutions to organizations across the mining, construction, and related industries. Our team connects qualified professionals with project-based and long-term opportunities while supporting the workforce needs of our clients.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is an equal opportunity employer. Employment decisions are made without regard to legally protected characteristics in accordance with applicable law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Administrative Assistant","post_link":"https:\/\/turnerstaffing.com\/position\/administrative-assistant\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%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=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is seeking a professional, organized, and service-oriented <strong>Administrative Assistant<\/strong> to support operations at a mining project in <strong>Elko, Nevada<\/strong>. This is a <strong>full-time, on-site, project-based assignment<\/strong> supporting site leadership and the broader project team.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The Administrative Assistant will provide day-to-day administrative, logistical, reporting, and office support while helping maintain an organized and efficient work environment. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position will work directly for <strong>Turner Staffing Group<\/strong> while supporting our client's mining project.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This opportunity may also be a strong fit for a <strong>current college or university student who is completing their degree<\/strong> and looking to gain professional experience in a project-based environment. Students are encouraged to apply as long as they can consistently work a <strong>full-time daytime schedule of either four 10-hour days or five 8-hour days per week<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The ideal candidate is proactive, detail-oriented, dependable, and comfortable working in a fast-paced environment. <strong>Strong Microsoft Excel skills are essential<\/strong>, including experience with data entry, data manipulation, tracking, and report preparation.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide day-to-day administrative support to site leadership and project personnel.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform accurate and timely data entry and maintain project records, spreadsheets, trackers, and reports.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Use Microsoft Excel to organize, manipulate, track, and report project-related information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prepare and update routine reports, spreadsheets, documents, and presentations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain organized electronic and physical files and documentation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with scheduling meetings, appointments, and project activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate meeting logistics and prepare materials as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support communication and information flow between site personnel, Turner Staffing Group, and project stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with onboarding coordination, employee documentation, and workforce-related administrative tasks as assigned.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support office supply, equipment, and general site office needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with travel, lodging, and other logistical coordination when required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Respond professionally to questions and requests from employees, supervisors, and project personnel.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain confidentiality when handling employee, project, and business information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Help maintain an organized, professional, and welcoming site office.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow applicable site safety requirements, policies, and procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide additional administrative and project support as needed.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous administrative, office, customer service, data entry, project support, or similar experience is preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Current college or university students are encouraged to apply<\/strong>, provided they can meet the full-time daytime work schedule.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Strong Microsoft Excel skills required<\/strong>, including experience with:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Data entry and spreadsheet maintenance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Sorting, filtering, and organizing data<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Data manipulation and cleanup<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Creating and maintaining trackers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preparing reports from spreadsheet data<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Formulas and standard Excel functions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong general computer skills, including Microsoft Office.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Excellent organizational skills and attention to detail.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong written and verbal communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Professional and service-oriented approach.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to manage multiple priorities and meet deadlines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to learn new processes and systems quickly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Dependable and able to maintain discretion with confidential information.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work independently while contributing effectively to a team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work <strong>40 hours per week during daytime business\/project hours<\/strong>, on either a <strong>4x10-hour or 5x8-hour schedule<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work <strong>on-site at a mining project near Elko, Nevada<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Mining, construction, industrial, or project-site experience is helpful but <strong>not required<\/strong>.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Who This Role Could Be a Good Fit For<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position could be an excellent opportunity for an <strong>early-career professional or college\/university student nearing completion of their degree<\/strong> who wants practical experience supporting a large-scale industrial project.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>This is not a part-time student position.<\/strong> <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Project-Based Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This is a <strong>full-time, project-based position with Turner Staffing Group<\/strong> supporting a mining client's project near Elko. For the right candidate, there is a <strong>possibility of transitioning to a direct-hire opportunity<\/strong> based on performance, overall fit, client needs, and project requirements. A transition to direct hire is not guaranteed.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">About Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group provides workforce solutions to organizations across the mining, construction, and related industries. Our team connects qualified professionals with project-based and long-term opportunities while supporting the workforce needs of our clients.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is an equal opportunity employer. Employment decisions are made without regard to legally protected characteristics in accordance with applicable law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/f8123ab549c2-administrative-assistant","%breezy_id%":"f8123ab549c2","%breezy_friendly_id%":"f8123ab549c2-administrative-assistant","%breezy_created_date%":"2026-08-19T15:39:01.837Z","%breezy_updated_date%":"2026-08-19T15:39:03.824Z","%_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%":"673"}},"id":3943,"infowindow_disable":false},{"source":"post","title":"Senior Modeling Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Modeling Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a Senior Modeling and Drilling Geologist for a direct-hire opportunity with our client in the&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-modeling-geologist\/\" name=\"Senior Modeling Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a Senior Modeling and Drilling Geologist for a direct-hire opportunity with our client in the&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\/senior-modeling-geologist\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a Senior Modeling and Drilling Geologist for a direct-hire opportunity with our client in the&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is seeking a <strong>Senior Modeling and Drilling Geologist<\/strong> for a direct-hire opportunity with our client in the mining industry.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position will lead gold exploration and resource definition programs from target generation through resource evaluation. The Senior Modeling and Drilling Geologist will provide technical leadership across drilling programs, geological interpretation, geological modeling, and project advancement while ensuring work is completed safely, efficiently, and in accordance with applicable regulatory and environmental requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The successful candidate will work closely with multidisciplinary teams, contractors, and stakeholders and play an important role in advancing exploration, resource development, and mine planning initiatives.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Plan diamond core and reverse circulation (RC) drilling programs for open-pit and underground environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Lead and manage exploration, near-mine, and resource definition drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop and manage drilling budgets, forecasts, schedules, and cost controls.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Implement and oversee QA\/QC programs for drilling, sampling, and assay data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure accurate collection, validation, and management of geological data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Review laboratory results and investigate data anomalies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain geological databases and established data-quality standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure geological and drilling activities comply with applicable environmental regulations and permitting requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Supervise geological staff, field technicians, and drilling contractors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Monitor project progress and recommend adjustments to achieve technical and business objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct core logging, structural interpretation, sampling quality reviews, and geological mapping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Interpret geological, structural, geochemical, and geophysical data to identify and evaluate controls on gold mineralization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop, refine, and update geological resource models using industry-standard software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support Mineral Resource estimation through geological modeling, data validation, and interpretation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prepare technical reports, presentations, and project updates for senior management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Contribute to Mineral Resource reports and applicable regulatory disclosure documents.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide geological input for feasibility studies and mine planning activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify opportunities to expand or upgrade mineral resources and reserves.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate exploration, near-mine, and resource definition results and recommendations to internal and external stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Manage team performance and support professional development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Promote a strong culture of safety and operational accountability.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Bachelor\u2019s degree in Geology, Geological Sciences, Earth Sciences, or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>8\u201312 years of progressively responsible geological experience<\/strong>, with significant experience in gold exploration, near-mine exploration, resource definition, and project development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated experience managing exploration and drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with geological modeling and Mineral Resource estimation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of relevant gold deposit systems, including orogenic, epithermal, intrusion-related, and\/or Carlin-style deposits.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience working in remote exploration or active mining environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated ability to manage consultants, contractors, budgets, and project schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proficiency with geological modeling software such as <strong>Leapfrog Geo, Micromine, Datamine, Vulcan<\/strong>, or similar platforms.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with GIS software such as <strong>ArcGIS or QGIS<\/strong> and geological databases.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of sampling, QA\/QC protocols, and geological data management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Working knowledge of Mineral Resource reporting standards such as <strong>NI 43-101, JORC Code, and\/or S-K 1300<\/strong>, as applicable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong analytical, problem-solving, and decision-making skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Excellent written and verbal communication skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Master\u2019s degree in Economic Geology or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Professional registration, or eligibility for registration, as a Professional Geologist (P.Geo., PG, or equivalent).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is committed to providing equal employment opportunities to qualified applicants in accordance with applicable federal, state, and local laws.<\/p>","post_title":"Senior Modeling Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/senior-modeling-geologist\/","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=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is seeking a <strong>Senior Modeling and Drilling Geologist<\/strong> for a direct-hire opportunity with our client in the mining industry.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position will lead gold exploration and resource definition programs from target generation through resource evaluation. The Senior Modeling and Drilling Geologist will provide technical leadership across drilling programs, geological interpretation, geological modeling, and project advancement while ensuring work is completed safely, efficiently, and in accordance with applicable regulatory and environmental requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The successful candidate will work closely with multidisciplinary teams, contractors, and stakeholders and play an important role in advancing exploration, resource development, and mine planning initiatives.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Plan diamond core and reverse circulation (RC) drilling programs for open-pit and underground environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Lead and manage exploration, near-mine, and resource definition drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop and manage drilling budgets, forecasts, schedules, and cost controls.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Implement and oversee QA\/QC programs for drilling, sampling, and assay data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure accurate collection, validation, and management of geological data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Review laboratory results and investigate data anomalies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain geological databases and established data-quality standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure geological and drilling activities comply with applicable environmental regulations and permitting requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Supervise geological staff, field technicians, and drilling contractors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Monitor project progress and recommend adjustments to achieve technical and business objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct core logging, structural interpretation, sampling quality reviews, and geological mapping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Interpret geological, structural, geochemical, and geophysical data to identify and evaluate controls on gold mineralization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop, refine, and update geological resource models using industry-standard software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support Mineral Resource estimation through geological modeling, data validation, and interpretation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prepare technical reports, presentations, and project updates for senior management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Contribute to Mineral Resource reports and applicable regulatory disclosure documents.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide geological input for feasibility studies and mine planning activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify opportunities to expand or upgrade mineral resources and reserves.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate exploration, near-mine, and resource definition results and recommendations to internal and external stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Manage team performance and support professional development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Promote a strong culture of safety and operational accountability.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Bachelor\u2019s degree in Geology, Geological Sciences, Earth Sciences, or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>8\u201312 years of progressively responsible geological experience<\/strong>, with significant experience in gold exploration, near-mine exploration, resource definition, and project development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated experience managing exploration and drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with geological modeling and Mineral Resource estimation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of relevant gold deposit systems, including orogenic, epithermal, intrusion-related, and\/or Carlin-style deposits.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience working in remote exploration or active mining environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated ability to manage consultants, contractors, budgets, and project schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proficiency with geological modeling software such as <strong>Leapfrog Geo, Micromine, Datamine, Vulcan<\/strong>, or similar platforms.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with GIS software such as <strong>ArcGIS or QGIS<\/strong> and geological databases.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of sampling, QA\/QC protocols, and geological data management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Working knowledge of Mineral Resource reporting standards such as <strong>NI 43-101, JORC Code, and\/or S-K 1300<\/strong>, as applicable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong analytical, problem-solving, and decision-making skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Excellent written and verbal communication skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Master\u2019s degree in Economic Geology or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Professional registration, or eligibility for registration, as a Professional Geologist (P.Geo., PG, or equivalent).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is committed to providing equal employment opportunities to qualified applicants in accordance with applicable federal, state, and local laws.<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/7aa7009dfea8-senior-modeling-geologist","%breezy_id%":"7aa7009dfea8","%breezy_friendly_id%":"7aa7009dfea8-senior-modeling-geologist","%breezy_created_date%":"2026-08-19T18:49:41.610Z","%breezy_updated_date%":"2026-08-19T18:49:43.923Z","%_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%":"674"}},"id":3944,"infowindow_disable":false},{"source":"post","title":"Senior Ore Control Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Ore Control Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a Senior Modeling and Drilling Geologist for a direct-hire opportunity with our client in the&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-ore-control-geologist\/\" name=\"Senior Ore Control Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a Senior Modeling and Drilling Geologist for a direct-hire opportunity with our client in the&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\/senior-ore-control-geologist\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a Senior Modeling and Drilling Geologist for a direct-hire opportunity with our client in the&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is seeking a <strong>Senior Modeling and Drilling Geologist<\/strong> for a direct-hire opportunity with our client in the mining industry.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position will lead gold exploration and resource definition programs from target generation through resource evaluation. The Senior Modeling and Drilling Geologist will provide technical leadership across drilling programs, geological interpretation, geological modeling, and project advancement while ensuring work is completed safely, efficiently, and in accordance with applicable regulatory and environmental requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The successful candidate will work closely with multidisciplinary teams, contractors, and stakeholders and play an important role in advancing exploration, resource development, and mine planning initiatives.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Plan diamond core and reverse circulation (RC) drilling programs for open-pit and underground environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Lead and manage exploration, near-mine, and resource definition drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop and manage drilling budgets, forecasts, schedules, and cost controls.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Implement and oversee QA\/QC programs for drilling, sampling, and assay data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure accurate collection, validation, and management of geological data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Review laboratory results and investigate data anomalies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain geological databases and established data-quality standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure geological and drilling activities comply with applicable environmental regulations and permitting requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Supervise geological staff, field technicians, and drilling contractors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Monitor project progress and recommend adjustments to achieve technical and business objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct core logging, structural interpretation, sampling quality reviews, and geological mapping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Interpret geological, structural, geochemical, and geophysical data to identify and evaluate controls on gold mineralization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop, refine, and update geological resource models using industry-standard software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support Mineral Resource estimation through geological modeling, data validation, and interpretation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prepare technical reports, presentations, and project updates for senior management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Contribute to Mineral Resource reports and applicable regulatory disclosure documents.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide geological input for feasibility studies and mine planning activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify opportunities to expand or upgrade mineral resources and reserves.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate exploration, near-mine, and resource definition results and recommendations to internal and external stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Manage team performance and support professional development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Promote a strong culture of safety and operational accountability.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Bachelor\u2019s degree in Geology, Geological Sciences, Earth Sciences, or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>8\u201312 years of progressively responsible geological experience<\/strong>, with significant experience in gold exploration, near-mine exploration, resource definition, and project development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated experience managing exploration and drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with geological modeling and Mineral Resource estimation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of relevant gold deposit systems, including orogenic, epithermal, intrusion-related, and\/or Carlin-style deposits.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience working in remote exploration or active mining environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated ability to manage consultants, contractors, budgets, and project schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proficiency with geological modeling software such as <strong>Leapfrog Geo, Micromine, Datamine, Vulcan<\/strong>, or similar platforms.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with GIS software such as <strong>ArcGIS or QGIS<\/strong> and geological databases.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of sampling, QA\/QC protocols, and geological data management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Working knowledge of Mineral Resource reporting standards such as <strong>NI 43-101, JORC Code, and\/or S-K 1300<\/strong>, as applicable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong analytical, problem-solving, and decision-making skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Excellent written and verbal communication skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Master\u2019s degree in Economic Geology or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Professional registration, or eligibility for registration, as a Professional Geologist (P.Geo., PG, or equivalent).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is committed to providing equal employment opportunities to qualified applicants in accordance with applicable federal, state, and local laws.<\/p>","post_title":"Senior Ore Control Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/senior-ore-control-geologist\/","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=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is seeking a <strong>Senior Modeling and Drilling Geologist<\/strong> for a direct-hire opportunity with our client in the mining industry.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position will lead gold exploration and resource definition programs from target generation through resource evaluation. The Senior Modeling and Drilling Geologist will provide technical leadership across drilling programs, geological interpretation, geological modeling, and project advancement while ensuring work is completed safely, efficiently, and in accordance with applicable regulatory and environmental requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The successful candidate will work closely with multidisciplinary teams, contractors, and stakeholders and play an important role in advancing exploration, resource development, and mine planning initiatives.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Plan diamond core and reverse circulation (RC) drilling programs for open-pit and underground environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Lead and manage exploration, near-mine, and resource definition drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop and manage drilling budgets, forecasts, schedules, and cost controls.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Implement and oversee QA\/QC programs for drilling, sampling, and assay data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure accurate collection, validation, and management of geological data.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Review laboratory results and investigate data anomalies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain geological databases and established data-quality standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure geological and drilling activities comply with applicable environmental regulations and permitting requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Supervise geological staff, field technicians, and drilling contractors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Monitor project progress and recommend adjustments to achieve technical and business objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct core logging, structural interpretation, sampling quality reviews, and geological mapping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Interpret geological, structural, geochemical, and geophysical data to identify and evaluate controls on gold mineralization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop, refine, and update geological resource models using industry-standard software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support Mineral Resource estimation through geological modeling, data validation, and interpretation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prepare technical reports, presentations, and project updates for senior management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Contribute to Mineral Resource reports and applicable regulatory disclosure documents.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide geological input for feasibility studies and mine planning activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify opportunities to expand or upgrade mineral resources and reserves.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate exploration, near-mine, and resource definition results and recommendations to internal and external stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Manage team performance and support professional development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Promote a strong culture of safety and operational accountability.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Bachelor\u2019s degree in Geology, Geological Sciences, Earth Sciences, or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>8\u201312 years of progressively responsible geological experience<\/strong>, with significant experience in gold exploration, near-mine exploration, resource definition, and project development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated experience managing exploration and drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with geological modeling and Mineral Resource estimation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of relevant gold deposit systems, including orogenic, epithermal, intrusion-related, and\/or Carlin-style deposits.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience working in remote exploration or active mining environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated ability to manage consultants, contractors, budgets, and project schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proficiency with geological modeling software such as <strong>Leapfrog Geo, Micromine, Datamine, Vulcan<\/strong>, or similar platforms.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with GIS software such as <strong>ArcGIS or QGIS<\/strong> and geological databases.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of sampling, QA\/QC protocols, and geological data management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Working knowledge of Mineral Resource reporting standards such as <strong>NI 43-101, JORC Code, and\/or S-K 1300<\/strong>, as applicable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong analytical, problem-solving, and decision-making skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Excellent written and verbal communication skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Master\u2019s degree in Economic Geology or a related discipline.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Professional registration, or eligibility for registration, as a Professional Geologist (P.Geo., PG, or equivalent).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equal Employment Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is committed to providing equal employment opportunities to qualified applicants in accordance with applicable federal, state, and local laws.<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/92ef2ee5e1d6-senior-ore-control-geologist","%breezy_id%":"92ef2ee5e1d6","%breezy_friendly_id%":"92ef2ee5e1d6-senior-ore-control-geologist","%breezy_created_date%":"2026-08-19T18:58:14.364Z","%breezy_updated_date%":"2026-08-19T18:58:17.285Z","%_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%":"675"}},"id":3945,"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    Overview Turner Staffing Group is hiring a Production Dozer Operator to support a mining operation in Hinkley, California. This is&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":"Overview Turner Staffing Group is hiring a Production Dozer 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\/dozer-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Overview Turner Staffing Group is hiring a Production Dozer Operator to support a mining operation in Hinkley, California. This is&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Overview<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is hiring a Production Dozer Operator to support a mining operation in Hinkley, California. This is a key production role responsible for efficiently pushing, spreading, and grading material to support material movement across the site.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">If you're 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate a bulldozer to push, spread, and grade overburden, ore, or aggregate material<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain consistent production rates while minimizing rework and material loss<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure proper dozing techniques to maximize efficiency and equipment longevity<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct pre-shift and post-shift inspections of equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify and report mechanical issues or unsafe conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all site safety policies and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate effectively with haul truck drivers, dispatch, and supervisors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain clean work areas, haul roads, and stockpiles, and assist with general production support as needed<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proven experience operating a dozer in a mining, quarry, or heavy civil environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of grading, material handling, and production goals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver's license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA certification (preferred; may be required prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in a physically demanding outdoor environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong situational awareness and commitment to safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reliable transportation and consistent attendance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We're Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operators who can push and grade material safely, efficiently, and consistently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Individuals who understand production targets and take ownership of performance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Team players who communicate clearly and work well in a fast-paced environment<\/li>\n<\/ul><h1 style=\"line-height:1.5;margin:0px\"><br><\/h1>","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%":"Hinkley","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Hinkley, CA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Overview<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is hiring a Production Dozer Operator to support a mining operation in Hinkley, California. This is a key production role responsible for efficiently pushing, spreading, and grading material to support material movement across the site.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">If you're 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate a bulldozer to push, spread, and grade overburden, ore, or aggregate material<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain consistent production rates while minimizing rework and material loss<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure proper dozing techniques to maximize efficiency and equipment longevity<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct pre-shift and post-shift inspections of equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify and report mechanical issues or unsafe conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all site safety policies and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate effectively with haul truck drivers, dispatch, and supervisors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain clean work areas, haul roads, and stockpiles, and assist with general production support as needed<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proven experience operating a dozer in a mining, quarry, or heavy civil environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of grading, material handling, and production goals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver's license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA certification (preferred; may be required prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in a physically demanding outdoor environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong situational awareness and commitment to safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reliable transportation and consistent attendance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We're Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operators who can push and grade material safely, efficiently, and consistently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Individuals who understand production targets and take ownership of performance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Team players who communicate clearly and work well in a fast-paced environment<\/li>\n<\/ul><h1 style=\"line-height:1.5;margin:0px;\"><br><\/h1>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/d854264029e5-dozer-operator","%breezy_id%":"d854264029e5","%breezy_friendly_id%":"d854264029e5-dozer-operator","%breezy_created_date%":"2026-08-19T19:54:46.417Z","%breezy_updated_date%":"2026-09-08T22:21:25.417Z","%_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","%rank_math_analytic_object_id%":"676"}},"id":3946,"infowindow_disable":false},{"source":"post","title":"Plant Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Plant Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Overview Turner Staffing Group is hiring a Plant Mechanic to support a mining operation in Hinkley, California. This is a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/plant-mechanic\/\" name=\"Plant Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Overview Turner Staffing Group is hiring a Plant Mechanic to support a mining operation in Hinkley, California. This is 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\/plant-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Overview Turner Staffing Group is hiring a Plant Mechanic to support a mining operation in Hinkley, California. This is a&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Overview<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is hiring a Plant Mechanic to support a mining operation in Hinkley, California. This is a key maintenance role responsible for keeping processing plant equipment running safely and efficiently to support continuous production.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">If you're an experienced mechanic who takes pride in reliability, precision, and safety, this is an opportunity to be part of a high-performing operation with room to grow.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span style=\"font-family:Arial;font-size:16px\"><span class=\"ql-cursor\">\ufeff<\/span><\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform preventative maintenance, troubleshooting, and repairs on processing plant equipment (crushers, conveyors, screens, pumps, and related machinery)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Diagnose mechanical, hydraulic, and pneumatic issues and complete repairs to minimize downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform welding, fabrication, and component replacement as needed<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct routine inspections to identify wear, damage, or unsafe conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain accurate maintenance logs and report on equipment condition and repairs completed<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all site safety policies and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate effectively with the maintenance team, operators, and supervisors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain a clean, organized, and safe work area<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proven experience as a mechanic in a mining, quarry, or industrial plant environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of mechanical, hydraulic, and electrical systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to read schematics and use diagnostic tools<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver's license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA certification (preferred; may be required prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in a physically demanding outdoor environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong situational awareness and commitment to safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reliable transportation and consistent attendance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We're Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Mechanics who can diagnose and repair issues safely, efficiently, and consistently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Individuals who take ownership of equipment reliability and uptime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Team players who communicate clearly and work well in a fast-paced environment<\/li>\n<\/ul><h1 style=\"line-height:1.5;margin:0px\"><br><\/h1>","post_title":"Plant Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/plant-mechanic\/","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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Overview<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is hiring a Plant Mechanic to support a mining operation in Hinkley, California. This is a key maintenance role responsible for keeping processing plant equipment running safely and efficiently to support continuous production.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">If you're an experienced mechanic who takes pride in reliability, precision, and safety, this is an opportunity to be part of a high-performing operation with room to grow.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);\"><span class=\"ql-cursor\">\ufeff<\/span><\/span><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform preventative maintenance, troubleshooting, and repairs on processing plant equipment (crushers, conveyors, screens, pumps, and related machinery)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Diagnose mechanical, hydraulic, and pneumatic issues and complete repairs to minimize downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform welding, fabrication, and component replacement as needed<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct routine inspections to identify wear, damage, or unsafe conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain accurate maintenance logs and report on equipment condition and repairs completed<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all site safety policies and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate effectively with the maintenance team, operators, and supervisors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain a clean, organized, and safe work area<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proven experience as a mechanic in a mining, quarry, or industrial plant environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of mechanical, hydraulic, and electrical systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to read schematics and use diagnostic tools<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver's license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA certification (preferred; may be required prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in a physically demanding outdoor environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong situational awareness and commitment to safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reliable transportation and consistent attendance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We're Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Mechanics who can diagnose and repair issues safely, efficiently, and consistently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Individuals who take ownership of equipment reliability and uptime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Team players who communicate clearly and work well in a fast-paced environment<\/li>\n<\/ul><h1 style=\"line-height:1.5;margin:0px;\"><br><\/h1>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a461a5e1c03e-plant-mechanic","%breezy_id%":"a461a5e1c03e","%breezy_friendly_id%":"a461a5e1c03e-plant-mechanic","%breezy_created_date%":"2026-08-19T19:57:31.923Z","%breezy_updated_date%":"2026-09-08T22:47:33.254Z","%_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","%rank_math_analytic_object_id%":"677"}},"id":3947,"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    Excavator Operator &#8211; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT 320 \u2013&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":"Excavator Operator &#8211; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT 320 \u2013&hellip;","address":"Charles Town, WV, USA","location":{"lat":"39.2889903","city":"Charles Town","state":"WV","country":"United States","lng":"-77.8597175","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Excavator Operator &#8211; Underground Utilities Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT 320 \u2013&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Excavator Operator - Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Fleet:<\/strong> CAT 320 \u2013 CAT 336 Excavators<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>About the Role<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you a skilled heavy equipment operator looking for a <strong>permanent, direct-hire opportunity<\/strong> with steady work and modern iron? We are hiring an experienced <strong>Excavator Operator<\/strong> to join our site utility team in <strong>Charles Town, WV<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you\u2019ll be a vital part of our underground utility crew, operating heavy production excavators (<strong>CAT 320 to CAT 336<\/strong>) to dig trenches, place pipe, and manage material on site. You will work directly under the guidance of our Team Lead to execute precise, safe, and efficient utility installations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Precision Excavation:<\/strong> Dig trenches to exact grade and depth for underground utility systems (water, sewer, storm, etc.) in dynamic soil conditions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Trench &amp; Pipe Operations:<\/strong> Lift, move, and position heavy pipe, trench boxes, and utility structures directly into the trench with precision and care.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Controlled Backfill:<\/strong> Place and compact backfill material in controlled lifts to ensure proper structural integrity and meet compaction specifications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Cross-Equipment Operation:<\/strong> Occasionally step into auxiliary machines, such as <strong>CAT 930 rubber-tired loaders<\/strong> or <strong>CAT 963 track loaders<\/strong>, to assist with site prep, material management, and stock piling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Daily Maintenance &amp; Logs:<\/strong> Perform standard pre-shift\/post-shift inspections and accurately complete daily equipment logs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Jobsite Safety:<\/strong> Maintain a strict safety-first mindset around open excavations, existing utility lines, and ground personnel.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> 2 years of heavy excavator operation required (<strong>3 to 5+ years preferred<\/strong>).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Underground Utility Focus:<\/strong> Direct experience working around underground utilities is required; <strong>pipelaying experience is highly preferred<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Fleet Familiarity:<\/strong> Demonstrated competency operating CAT 320 to 336 class excavators (or equivalent mid-to-heavy machines).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Versatility:<\/strong> Willingness to operate support machinery (CAT 930 loader \/ CAT 963 track loader) when needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Reliability &amp; Teamwork:<\/strong> Strong work ethic, reliable attendance, and ability to collaborate effectively with field team members and the Team Lead.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charles Town","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Charles Town, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Excavator Operator - Underground Utilities<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Fleet:<\/strong> CAT 320 \u2013 CAT 336 Excavators<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Reports To:<\/strong> Team Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>About the Role<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you a skilled heavy equipment operator looking for a <strong>permanent, direct-hire opportunity<\/strong> with steady work and modern iron? We are hiring an experienced <strong>Excavator Operator<\/strong> to join our site utility team in <strong>Charles Town, WV<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you\u2019ll be a vital part of our underground utility crew, operating heavy production excavators (<strong>CAT 320 to CAT 336<\/strong>) to dig trenches, place pipe, and manage material on site. You will work directly under the guidance of our Team Lead to execute precise, safe, and efficient utility installations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Precision Excavation:<\/strong> Dig trenches to exact grade and depth for underground utility systems (water, sewer, storm, etc.) in dynamic soil conditions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Trench &amp; Pipe Operations:<\/strong> Lift, move, and position heavy pipe, trench boxes, and utility structures directly into the trench with precision and care.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Controlled Backfill:<\/strong> Place and compact backfill material in controlled lifts to ensure proper structural integrity and meet compaction specifications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Cross-Equipment Operation:<\/strong> Occasionally step into auxiliary machines, such as <strong>CAT 930 rubber-tired loaders<\/strong> or <strong>CAT 963 track loaders<\/strong>, to assist with site prep, material management, and stock piling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Daily Maintenance &amp; Logs:<\/strong> Perform standard pre-shift\/post-shift inspections and accurately complete daily equipment logs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Jobsite Safety:<\/strong> Maintain a strict safety-first mindset around open excavations, existing utility lines, and ground personnel.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> 2 years of heavy excavator operation required (<strong>3 to 5+ years preferred<\/strong>).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Underground Utility Focus:<\/strong> Direct experience working around underground utilities is required; <strong>pipelaying experience is highly preferred<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Fleet Familiarity:<\/strong> Demonstrated competency operating CAT 320 to 336 class excavators (or equivalent mid-to-heavy machines).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Versatility:<\/strong> Willingness to operate support machinery (CAT 930 loader \/ CAT 963 track loader) when needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Reliability &amp; Teamwork:<\/strong> Strong work ethic, reliable attendance, and ability to collaborate effectively with field team members and the Team Lead.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/59da5f2ef0d1-excavator-operator","%breezy_id%":"59da5f2ef0d1","%breezy_friendly_id%":"59da5f2ef0d1-excavator-operator","%breezy_created_date%":"2026-08-20T15:16:19.620Z","%breezy_updated_date%":"2026-08-20T15:16:21.518Z","%_wpgmp_location_city%":"Charles Town","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charles Town, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2889903","%_wpgmp_metabox_longitude%":"-77.8597175","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"678"}},"id":3948,"infowindow_disable":false},{"source":"post","title":"Dozer Operator (Team Lead)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator (Team Lead)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    GPS Dozer Operator \/ Team Lead Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead\/\" name=\"Dozer Operator (Team Lead)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"GPS Dozer Operator \/ Team Lead Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;","address":"Charles Town, WV, USA","location":{"lat":"39.2889903","city":"Charles Town","state":"WV","country":"United States","lng":"-77.8597175","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead\/","zoom":19,"extra_fields":{"post_excerpt":"GPS Dozer Operator \/ Team Lead Location: Charles Town, WV Position Type: Direct Placement (Full-Time, Permanent) Primary Fleet: CAT D3,&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><u>GPS Dozer Operator \/ Team Lead<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Primary Fleet:<\/strong> CAT D3, D5\/DK, D6K, D6 XE, D8 Dozers<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Reports To:<\/strong> Project Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>About the Role<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Are you an experienced dozer operator who knows <strong>Trimble 3D GPS<\/strong> inside and out and thrives in a leadership role? We are seeking a <strong>GPS Dozer Operator \/ Team Lead<\/strong> for a <strong>direct placement position<\/strong> with one of our top civil earthwork clients in <strong>Charles Town, WV<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">In this role, you\u2019ll lead from the cab and on the ground\u2014running high-production Caterpillar iron, setting up and verifying 3D site models, and directing field crews to complete mass earthwork projects on time and on grade.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Precision Grading &amp; Earthmoving:<\/strong> Operate a full spectrum of CAT dozers (<strong>D3, D6K, D5\/DK, D6 XE Electric Drive, and D8<\/strong>) for mass excavation, fine grading, subgrade preparation, and site setup.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Trimble GPS &amp; Model Verification:<\/strong> Set up Trimble GPS base stations\/rovers, lay out grade stakes, verify digital terrain models against plans, and troubleshoot grade adjustments on the fly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Crew Leadership &amp; Coordination:<\/strong> Serve as a working Team Lead\u2014directing site personnel, delegating daily tasks, keeping work moving efficiently, and reporting progress to the Project Lead.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Production Tracking &amp; Daily Logs:<\/strong> Complete daily equipment logs and track site production quantities, equipment hours, and delays using <strong>HeavyJob<\/strong> or daily log software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Auxiliary Equipment Operation:<\/strong> Step into support iron when needed, including skid steers, rollers, and track loaders to keep operations fluid.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Jobsite Safety:<\/strong> Lead daily safety briefings (toolbox talks) and enforce zero-compromise safety protocols around heavy machinery and active earthwork zones.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Experience:<\/strong> 4+ years of heavy dozer operation required (preferably focused on civil earthwork and site development).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>GPS Expertise:<\/strong> 2+ years of hands-on experience utilizing <strong>Trimble GPS-guided systems<\/strong>, including model verification and grade layout.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Leadership Background:<\/strong> 2+ years of experience leading site crews and managing daily field workflows.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required (willingness to obtain OSHA 30 is required).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Reporting &amp; Tech Proficiency:<\/strong> Familiarity with <strong>HeavyJob<\/strong> or electronic daily project logging tools.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Machine Versatility:<\/strong> Competency across small-to-large dozers (CAT D3 to D8) and basic support iron (skid steers\/rollers).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Dozer Operator (Team Lead)","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-team-lead\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charles Town","%location_state_id%":"WV","%location_state_name%":"West Virginia","%location_city_state%":"Charles Town, WV","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><u>GPS Dozer Operator \/ Team Lead<\/u><\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Location:<\/strong> Charles Town, WV<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Position Type:<\/strong> Direct Placement (Full-Time, Permanent)<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Primary Fleet:<\/strong> CAT D3, D5\/DK, D6K, D6 XE, D8 Dozers<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Reports To:<\/strong> Project Lead<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>About the Role<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Are you an experienced dozer operator who knows <strong>Trimble 3D GPS<\/strong> inside and out and thrives in a leadership role? We are seeking a <strong>GPS Dozer Operator \/ Team Lead<\/strong> for a <strong>direct placement position<\/strong> with one of our top civil earthwork clients in <strong>Charles Town, WV<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">In this role, you\u2019ll lead from the cab and on the ground\u2014running high-production Caterpillar iron, setting up and verifying 3D site models, and directing field crews to complete mass earthwork projects on time and on grade.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Precision Grading &amp; Earthmoving:<\/strong> Operate a full spectrum of CAT dozers (<strong>D3, D6K, D5\/DK, D6 XE Electric Drive, and D8<\/strong>) for mass excavation, fine grading, subgrade preparation, and site setup.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Trimble GPS &amp; Model Verification:<\/strong> Set up Trimble GPS base stations\/rovers, lay out grade stakes, verify digital terrain models against plans, and troubleshoot grade adjustments on the fly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Crew Leadership &amp; Coordination:<\/strong> Serve as a working Team Lead\u2014directing site personnel, delegating daily tasks, keeping work moving efficiently, and reporting progress to the Project Lead.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Production Tracking &amp; Daily Logs:<\/strong> Complete daily equipment logs and track site production quantities, equipment hours, and delays using <strong>HeavyJob<\/strong> or daily log software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Auxiliary Equipment Operation:<\/strong> Step into support iron when needed, including skid steers, rollers, and track loaders to keep operations fluid.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Jobsite Safety:<\/strong> Lead daily safety briefings (toolbox talks) and enforce zero-compromise safety protocols around heavy machinery and active earthwork zones.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidate Requirements<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Experience:<\/strong> 4+ years of heavy dozer operation required (preferably focused on civil earthwork and site development).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>GPS Expertise:<\/strong> 2+ years of hands-on experience utilizing <strong>Trimble GPS-guided systems<\/strong>, including model verification and grade layout.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Leadership Background:<\/strong> 2+ years of experience leading site crews and managing daily field workflows.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Certifications:<\/strong> Valid Driver's License and <strong>OSHA 10 Certification<\/strong> required (willingness to obtain OSHA 30 is required).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Reporting &amp; Tech Proficiency:<\/strong> Familiarity with <strong>HeavyJob<\/strong> or electronic daily project logging tools.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Machine Versatility:<\/strong> Competency across small-to-large dozers (CAT D3 to D8) and basic support iron (skid steers\/rollers).<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/c357dcac029e-dozer-operator-team-lead","%breezy_id%":"c357dcac029e","%breezy_friendly_id%":"c357dcac029e-dozer-operator-team-lead","%breezy_created_date%":"2026-08-20T15:51:34.646Z","%breezy_updated_date%":"2026-08-20T15:51:37.643Z","%_wpgmp_location_city%":"Charles Town","%_wpgmp_location_state%":"WV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charles Town, WV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2889903","%_wpgmp_metabox_longitude%":"-77.8597175","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"679"}},"id":3949,"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    Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-layer-2\/\" name=\"Pipe Layer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;","address":"Lancaster, PA, USA","location":{"lat":"40.0403279","city":"Lancaster","state":"PA","country":"United States","lng":"-76.3041833","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pipe-layer-2\/","zoom":19,"extra_fields":{"post_excerpt":"Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;","post_content":"<p>Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers REAL growth?<\/p>\n<p><br><\/p>\n<p>We\u2019ve been waiting for you!<br><br><\/p>\n\n<p>You want to work for a services company that is rapidly changing the way the way pipe work is conducted. 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 safety oriented, hard working individual 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><br><\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n\n<ul>\n<li>Laborer duties include pipe rehabilitation, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li>\n<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>\n<li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<li>Willingness to learn operating equipment<\/li>\n<li>Team Player with GREAT attitude!<\/li><\/ul>\n<p><strong>Requirements:<\/strong><br><\/p>\n\n<ul>\n<li>Driver's License<\/li>\n<li>Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li>Knowledge of DOT Regulations<\/li>\n<li>Experience in heavy highway utility work&nbsp;<\/li>\n<li>Strong work ethic<\/li>\n<li>Willingness to learn<\/li>\n<li>Ability to be flexible and to adapt<\/li>\n<li>Experience with heavy equipment<\/li>\n<\/ul>","post_title":"Pipe Layer","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-layer-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Lancaster","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Lancaster, PA","%education%":"","%department%":"TSG","%description%":"<p>Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers REAL growth?<\/p>\n<p><br><\/p>\n<p>We\u2019ve been waiting for you!<br><br><\/p>\n\n<p>You want to work for a services company that is rapidly changing the way the way pipe work is conducted. 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 safety oriented, hard working individual 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><br><\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n\n<ul>\n<li>Laborer duties include pipe rehabilitation, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li>\n<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>\n<li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<li>Willingness to learn operating equipment<\/li>\n<li>Team Player with GREAT attitude!<\/li><\/ul>\n<p><strong>Requirements:<\/strong><br><\/p>\n\n<ul>\n<li>Driver's License<\/li>\n<li>Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li>Knowledge of DOT Regulations<\/li>\n<li>Experience in heavy highway utility work&nbsp;<\/li>\n<li>Strong work ethic<\/li>\n<li>Willingness to learn<\/li>\n<li>Ability to be flexible and to adapt<\/li>\n<li>Experience with heavy equipment<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/05081fb1b5b0-pipe-layer","%breezy_id%":"05081fb1b5b0","%breezy_friendly_id%":"05081fb1b5b0-pipe-layer","%breezy_created_date%":"2026-08-13T18:58:51.609Z","%breezy_updated_date%":"2026-09-10T18:46:22.085Z","%_wpgmp_location_city%":"Lancaster","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lancaster, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.0403279","%_wpgmp_metabox_longitude%":"-76.3041833","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"666"}},"id":3936,"infowindow_disable":false},{"source":"post","title":"Construction Materials Testing Field Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Construction Materials Testing Field Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    TURNER STAFFING GROUP Connecting Talented Professionals with Great Opportunities Field Technician 1 &#8211; Construction Materials Testing St. Louis, Missouri&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site \/&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/construction-materials-testing-field-technician\/\" name=\"Construction Materials Testing Field Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"TURNER STAFFING GROUP Connecting Talented Professionals with Great Opportunities Field Technician 1 &#8211; Construction Materials Testing St. Louis, Missouri&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site \/&hellip;","address":"St. Louis, MO, USA","location":{"lat":"38.627428","city":"St. Louis","state":"MO","country":"United States","lng":"-90.1982439","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/construction-materials-testing-field-technician\/","zoom":19,"extra_fields":{"post_excerpt":"TURNER STAFFING GROUP Connecting Talented Professionals with Great Opportunities Field Technician 1 &#8211; Construction Materials Testing St. Louis, Missouri&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site \/&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px;text-align:center\"><strong>TURNER STAFFING GROUP<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px;text-align:center\"><em>Connecting Talented Professionals with Great Opportunities<\/em><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px;text-align:center\"><strong>Field Technician 1 - Construction Materials Testing<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px;text-align:center\">St. Louis, Missouri&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site \/ Field-Based<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px;text-align:center\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is partnering with our client, a leading provider of construction assurance, testing, and inspection services for civil and commercial construction, to find an Entry Level Field Technician I in St. Louis, Missouri. This is a great launching point for a versatile career in the architectural, engineering, and construction (A\/E\/C) industry, with hands-on exposure to construction materials testing, geotechnical services, environmental engineering, and more.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You'll Do<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Operate testing equipment and conduct testing (soil, concrete, and other materials), providing assessment of data through reporting.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Utilize drawings, specifications, and diagrams to guide fieldwork.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Use established methods to make detailed observations of site activities and provide limited interpretation of results.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain detailed documentation and data from test results.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Bring<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1 year of construction-related field experience.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Valid driver's license and reliable driving record.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Willingness to work off-shift and overtime as needed.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to lift, move, push, and pull 30\u201350 lbs frequently, and 50+ lbs occasionally with assistance.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to hear and process detailed information through oral communication, including sound discrimination.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to kneel and squat occasionally, and to walk\/stand for extended periods.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Comfortable working outdoors in adverse weather, including hot and cold temperatures.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to climb occasionally and work at various heights.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Nice to Have<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;High school diploma or equivalent.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ACI Certification.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What's In It For You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Competitive compensation package.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Medical, dental, vision, life, and disability coverage.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;401(k) with company match.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Generous vacation\/sick time (PTO).<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Tuition reimbursement and more.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Interested in learning more?<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Apply today through Turner Staffing Group to be considered for this opportunity with our client.<\/p><h1 style=\"line-height:1.5;margin:0px\"><br><\/h1>","post_title":"Construction Materials Testing Field Technician","post_link":"https:\/\/turnerstaffing.com\/position\/construction-materials-testing-field-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"St. Louis","%location_state_id%":"MO","%location_state_name%":"Missouri","%location_city_state%":"St. Louis, MO","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;text-align:center;\"><strong>TURNER STAFFING GROUP<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;text-align:center;\"><em>Connecting Talented Professionals with Great Opportunities<\/em><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;text-align:center;\"><strong>Field Technician 1 - Construction Materials Testing<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;text-align:center;\">St. Louis, Missouri&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site \/ Field-Based<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;text-align:center;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is partnering with our client, a leading provider of construction assurance, testing, and inspection services for civil and commercial construction, to find an Entry Level Field Technician I in St. Louis, Missouri. This is a great launching point for a versatile career in the architectural, engineering, and construction (A\/E\/C) industry, with hands-on exposure to construction materials testing, geotechnical services, environmental engineering, and more.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You'll Do<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Operate testing equipment and conduct testing (soil, concrete, and other materials), providing assessment of data through reporting.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Utilize drawings, specifications, and diagrams to guide fieldwork.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Use established methods to make detailed observations of site activities and provide limited interpretation of results.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain detailed documentation and data from test results.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Bring<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;1 year of construction-related field experience.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Valid driver's license and reliable driving record.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Willingness to work off-shift and overtime as needed.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to lift, move, push, and pull 30\u201350 lbs frequently, and 50+ lbs occasionally with assistance.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to hear and process detailed information through oral communication, including sound discrimination.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to kneel and squat occasionally, and to walk\/stand for extended periods.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Comfortable working outdoors in adverse weather, including hot and cold temperatures.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to climb occasionally and work at various heights.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Nice to Have<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;High school diploma or equivalent.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ACI Certification.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What's In It For You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Competitive compensation package.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Medical, dental, vision, life, and disability coverage.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;401(k) with company match.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Generous vacation\/sick time (PTO).<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Tuition reimbursement and more.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Interested in learning more?<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Apply today through Turner Staffing Group to be considered for this opportunity with our client.<\/p><h1 style=\"line-height:1.5;margin:0px;\"><br><\/h1>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/5f2c562b7a8f-construction-materials-testing-field-technician","%breezy_id%":"5f2c562b7a8f","%breezy_friendly_id%":"5f2c562b7a8f-construction-materials-testing-field-technician","%breezy_created_date%":"2026-08-14T20:03:16.675Z","%breezy_updated_date%":"2026-09-08T22:10:10.049Z","%_wpgmp_location_city%":"St. Louis","%_wpgmp_location_state%":"MO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"St. Louis, MO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.627428","%_wpgmp_metabox_longitude%":"-90.1982439","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"667"}},"id":3937,"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    \ud83d\udd25 Heavy Equipment Operator | Limestone Quarry \ud83d\udccd Crawford, TX We\u2019re hiring a hands-on Heavy Equipment Operator to support a&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":"\ud83d\udd25 Heavy Equipment Operator | Limestone Quarry \ud83d\udccd Crawford, TX We\u2019re hiring a hands-on Heavy Equipment Operator to support a&hellip;","address":"Crawford, TX, USA","location":{"lat":"31.5343308","city":"Crawford","state":"TX","country":"United States","lng":"-97.44307","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-3\/","zoom":19,"extra_fields":{"post_excerpt":"\ud83d\udd25 Heavy Equipment Operator | Limestone Quarry \ud83d\udccd Crawford, TX We\u2019re hiring a hands-on Heavy Equipment Operator to support a&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\ud83d\udd25 Heavy Equipment Operator | Limestone Quarry<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\ud83d\udccd Crawford, TX<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We\u2019re hiring a hands-on Heavy Equipment Operator to support a limestone mining operation in Crawford, TX. If you can run equipment, stay production-focused, and jump in where needed, this is a solid, long-term opportunity in a high-demand industry.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\ud83d\udca5 What You\u2019ll Do<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate heavy equipment: loaders, haul trucks, dozers, water trucks, skid steers, drills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support crusher operations + rock breaker<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform pre-shift inspections and keep equipment running safely<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Handle material movement, loading, and plant cleanup<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with quarry blasting operations (ATF background required)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Track production data, weights, and daily logs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform basic maintenance (grease, fluids, inspections)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2699\ufe0f What You Bring<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience operating equipment in quarry, mining, construction, or heavy industrial environments<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong focus on safety + production<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willingness to work outdoors (heat, dust, noise)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comfortable with physical work (50\u201365 lbs) and manual labor<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Team player with solid communication skills<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\ud83d\udccb Requirements<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High school diploma or GED<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">0\u20133+ years experience (mining\/aggregates preferred)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver\u2019s license + clean driving record<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work shifts, overtime, weekends, and holidays<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must pass ATF background check (blasting support)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\ud83d\udea7 Why This Role<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Stable work in a limestone quarry operation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Variety of work\u2014equipment + plant + quarry support<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Opportunity to grow into advanced operator or maintenance roles<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","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%":"Crawford","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crawford, TX","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\ud83d\udd25 Heavy Equipment Operator | Limestone Quarry<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\ud83d\udccd Crawford, TX<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We\u2019re hiring a hands-on Heavy Equipment Operator to support a limestone mining operation in Crawford, TX. If you can run equipment, stay production-focused, and jump in where needed, this is a solid, long-term opportunity in a high-demand industry.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\ud83d\udca5 What You\u2019ll Do<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate heavy equipment: loaders, haul trucks, dozers, water trucks, skid steers, drills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support crusher operations + rock breaker<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform pre-shift inspections and keep equipment running safely<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Handle material movement, loading, and plant cleanup<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with quarry blasting operations (ATF background required)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Track production data, weights, and daily logs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform basic maintenance (grease, fluids, inspections)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2699\ufe0f What You Bring<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience operating equipment in quarry, mining, construction, or heavy industrial environments<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong focus on safety + production<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willingness to work outdoors (heat, dust, noise)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comfortable with physical work (50\u201365 lbs) and manual labor<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Team player with solid communication skills<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\ud83d\udccb Requirements<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High school diploma or GED<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">0\u20133+ years experience (mining\/aggregates preferred)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver\u2019s license + clean driving record<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work shifts, overtime, weekends, and holidays<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must pass ATF background check (blasting support)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\ud83d\udea7 Why This Role<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Stable work in a limestone quarry operation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Variety of work\u2014equipment + plant + quarry support<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Opportunity to grow into advanced operator or maintenance roles<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/370ac7c0d941-heavy-equipment-operator","%breezy_id%":"370ac7c0d941","%breezy_friendly_id%":"370ac7c0d941-heavy-equipment-operator","%breezy_created_date%":"2026-08-19T03:22:37.598Z","%breezy_updated_date%":"2026-08-19T03:22:39.476Z","%_wpgmp_location_city%":"Crawford","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crawford, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.5343308","%_wpgmp_metabox_longitude%":"-97.44307","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"668"}},"id":3938,"infowindow_disable":false},{"source":"post","title":"Heavy Mobile Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Mobile Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    &nbsp;HEAVY EQUIPMENT MECHANIC If you know diesel engines and heavy equipment, we want to hear from you! We\u2019re looking for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-mobile-equipment-mechanic-2\/\" name=\"Heavy Mobile Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"&nbsp;HEAVY EQUIPMENT MECHANIC If you know diesel engines and heavy equipment, we want to hear from you! We\u2019re looking for&hellip;","address":"Crawford, TX, USA","location":{"lat":"31.5343308","city":"Crawford","state":"TX","country":"United States","lng":"-97.44307","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-mobile-equipment-mechanic-2\/","zoom":19,"extra_fields":{"post_excerpt":"&nbsp;HEAVY EQUIPMENT MECHANIC If you know diesel engines and heavy equipment, we want to hear from you! We\u2019re looking for&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f527\/32.png\">&nbsp;HEAVY EQUIPMENT MECHANIC<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>If you know diesel engines and heavy equipment, we want to hear from you!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We\u2019re looking for an experienced <strong>Heavy Equipment\/Diesel Mechanic<\/strong> to keep our equipment running safely and efficiently.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f69c\/32.png\">&nbsp;What You\u2019ll Work On<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Haul Trucks<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Wheel Loaders<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Skid Steers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Dozers &amp; Motor Graders<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Pickups &amp; other mobile equipment<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f6e0\/32.png\">&nbsp;What You\u2019ll Do<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform preventative maintenance, troubleshooting &amp; repairs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Diagnose <strong>diesel engines, hydraulics &amp; electrical systems<\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Repair brakes, bearings, axles, wiring, seals and other components<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Complete engine\/component overhauls<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MIG\/arc welding &amp; torch cutting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Complete work orders and maintenance documentation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform equipment safety inspections<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/2b50\/32.png\">&nbsp;What We\u2019re Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>3\u20135+ years<\/strong> of heavy equipment\/diesel mechanic experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong diesel troubleshooting skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with <strong>hydraulics, electrical &amp; welding<\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety-focused and dependable<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Able to work independently in a fast-paced environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High School Diploma\/GED required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Technical training is a plus!<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f4aa\/32.png\">&nbsp;Must be able to lift 75+ lbs and work in industrial\/outdoor conditions.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Experienced heavy equipment mechanics \u2014 apply today!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Heavy Mobile Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-mobile-equipment-mechanic-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Crawford","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crawford, TX","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f527\/32.png\">&nbsp;HEAVY EQUIPMENT MECHANIC<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>If you know diesel engines and heavy equipment, we want to hear from you!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We\u2019re looking for an experienced <strong>Heavy Equipment\/Diesel Mechanic<\/strong> to keep our equipment running safely and efficiently.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f69c\/32.png\">&nbsp;What You\u2019ll Work On<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Haul Trucks<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Wheel Loaders<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Skid Steers<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Dozers &amp; Motor Graders<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Pickups &amp; other mobile equipment<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f6e0\/32.png\">&nbsp;What You\u2019ll Do<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform preventative maintenance, troubleshooting &amp; repairs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Diagnose <strong>diesel engines, hydraulics &amp; electrical systems<\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Repair brakes, bearings, axles, wiring, seals and other components<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Complete engine\/component overhauls<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MIG\/arc welding &amp; torch cutting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Complete work orders and maintenance documentation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform equipment safety inspections<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/2b50\/32.png\">&nbsp;What We\u2019re Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>3\u20135+ years<\/strong> of heavy equipment\/diesel mechanic experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong diesel troubleshooting skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with <strong>hydraulics, electrical &amp; welding<\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety-focused and dependable<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Able to work independently in a fast-paced environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High School Diploma\/GED required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Technical training is a plus!<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><img src=\"https:\/\/fonts.gstatic.com\/s\/e\/notoemoji\/17.0\/1f4aa\/32.png\">&nbsp;Must be able to lift 75+ lbs and work in industrial\/outdoor conditions.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Experienced heavy equipment mechanics \u2014 apply today!<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ec62d5453d16-heavy-mobile-equipment-mechanic","%breezy_id%":"ec62d5453d16","%breezy_friendly_id%":"ec62d5453d16-heavy-mobile-equipment-mechanic","%breezy_created_date%":"2026-08-19T03:56:05.857Z","%breezy_updated_date%":"2026-08-19T03:56:07.832Z","%_wpgmp_location_city%":"Crawford","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crawford, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.5343308","%_wpgmp_metabox_longitude%":"-97.44307","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"669","%rank_math_og_content_image%":{"check":"958f2d77ebff00c7c711ceef1b67300b","images":[]}}},"id":3939,"infowindow_disable":false},{"source":"post","title":"Engineering Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Engineering Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking an Engineering Technician \u2013 Underground Geotechnical for a 3-month project supporting Technical Services with our&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/engineering-technician\/\" name=\"Engineering Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking an Engineering Technician \u2013 Underground Geotechnical for a 3-month project supporting Technical Services with our&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\/engineering-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking an Engineering Technician \u2013 Underground Geotechnical for a 3-month project supporting Technical Services with our&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is seeking an <strong>Engineering Technician \u2013 Underground Geotechnical<\/strong> for a 3-month project supporting Technical Services with our mining client.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position will work in an underground mining environment supporting geotechnical activities, ground support practices, field testing, monitoring, data collection, and general technical services activities. The ideal candidate will have underground mining experience and working knowledge of ground support systems, including rock bolts, cable bolts, shotcrete, and fibercrete.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This is a hands-on field position requiring a strong commitment to safe work practices, effective communication, teamwork, and the ability to perform work in an underground environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsibilities<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Depending on experience, training, and site requirements, responsibilities may include:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support underground geotechnical and ground-control activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform field observations and help identify potential ground hazards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support ground support compliance activities and inspections.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with testing, monitoring, and data collection associated with underground ground support systems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform shotcrete testing activities, which may include UCS testing, thickness testing, slump testing, sample preparation, and data entry.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with rock bolt and ground support testing, including pull testing and related data collection.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support instrumentation monitoring and the installation, monitoring, and maintenance of geotechnical instruments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with crack monitor installation and monitoring.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support underground heading inspections and field observations as assigned.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with ground support rehabilitation or damage mapping activities when required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Enter and maintain technical and testing data in accordance with established processes.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain, organize, and inventory tools, materials, and technical supplies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support instrument calibration and equipment readiness as assigned.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in ground support trials and other Technical Services activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow site-specific safety procedures, supervisor instructions, and applicable Trigger Action Response Plans (TARPs).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain good housekeeping and safe work practices throughout the assignment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work collaboratively with engineering, operations, and other site personnel.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Required \/ Preferred Experience<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Underground mining experience with knowledge of ground support systems, including <strong>rock bolts, cable bolts, shotcrete, and fibercrete<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Familiarity with <strong>shotcrete\/concrete application and underground ground support practices<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong safety focus and ability to recognize and appropriately respond to underground ground hazards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to follow established procedures and supervisor direction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Effective communication and teamwork skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability and willingness to work in an underground mining environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work the assigned rotating schedule.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to perform the essential functions associated with a field-based underground position.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with one or more of the following is beneficial:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ground support compliance audits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Geotechnical instrumentation and monitoring<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Shotcrete or concrete testing<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Rock bolt testing<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Underground heading inspections<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Geotechnical data collection and reporting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Deswik or similar mining software<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Underground mobile equipment<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Training &amp; Safety<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must meet applicable site training and authorization requirements. The supporting position documentation identifies <strong>40-hour MSHA or MSHA Experienced Miner training, as applicable, and site-specific underground training<\/strong> within the Geotechnical Technician progression framework.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety is a core responsibility of this position. The selected candidate will be expected to follow all applicable safety, environmental, site, and operational procedures throughout the assignment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assignment Details<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This is a <strong>temporary staffing assignment anticipated to last approximately three months<\/strong>. The position is scheduled to work a <strong>5x4 \/ 4x4 rotation<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assignment duration, schedule, duties, and other working conditions may be adjusted based on operational requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">About Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group provides skilled professionals to organizations across the mining, construction, and related technical industries. Our staffing team connects qualified candidates with opportunities that match their experience while supporting our clients' workforce needs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is an equal opportunity employer. We make employment decisions without regard to legally protected characteristics, in accordance with applicable law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Engineering Technician","post_link":"https:\/\/turnerstaffing.com\/position\/engineering-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is seeking an <strong>Engineering Technician \u2013 Underground Geotechnical<\/strong> for a 3-month project supporting Technical Services with our mining client.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position will work in an underground mining environment supporting geotechnical activities, ground support practices, field testing, monitoring, data collection, and general technical services activities. The ideal candidate will have underground mining experience and working knowledge of ground support systems, including rock bolts, cable bolts, shotcrete, and fibercrete.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This is a hands-on field position requiring a strong commitment to safe work practices, effective communication, teamwork, and the ability to perform work in an underground environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Depending on experience, training, and site requirements, responsibilities may include:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support underground geotechnical and ground-control activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform field observations and help identify potential ground hazards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support ground support compliance activities and inspections.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with testing, monitoring, and data collection associated with underground ground support systems.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform shotcrete testing activities, which may include UCS testing, thickness testing, slump testing, sample preparation, and data entry.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with rock bolt and ground support testing, including pull testing and related data collection.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support instrumentation monitoring and the installation, monitoring, and maintenance of geotechnical instruments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with crack monitor installation and monitoring.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support underground heading inspections and field observations as assigned.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with ground support rehabilitation or damage mapping activities when required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Enter and maintain technical and testing data in accordance with established processes.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain, organize, and inventory tools, materials, and technical supplies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support instrument calibration and equipment readiness as assigned.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in ground support trials and other Technical Services activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow site-specific safety procedures, supervisor instructions, and applicable Trigger Action Response Plans (TARPs).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain good housekeeping and safe work practices throughout the assignment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work collaboratively with engineering, operations, and other site personnel.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Required \/ Preferred Experience<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Underground mining experience with knowledge of ground support systems, including <strong>rock bolts, cable bolts, shotcrete, and fibercrete<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Familiarity with <strong>shotcrete\/concrete application and underground ground support practices<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong safety focus and ability to recognize and appropriately respond to underground ground hazards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to follow established procedures and supervisor direction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Effective communication and teamwork skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability and willingness to work in an underground mining environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work the assigned rotating schedule.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to perform the essential functions associated with a field-based underground position.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with one or more of the following is beneficial:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ground support compliance audits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Geotechnical instrumentation and monitoring<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Shotcrete or concrete testing<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Rock bolt testing<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Underground heading inspections<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Geotechnical data collection and reporting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Deswik or similar mining software<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Underground mobile equipment<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Training &amp; Safety<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must meet applicable site training and authorization requirements. The supporting position documentation identifies <strong>40-hour MSHA or MSHA Experienced Miner training, as applicable, and site-specific underground training<\/strong> within the Geotechnical Technician progression framework.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety is a core responsibility of this position. The selected candidate will be expected to follow all applicable safety, environmental, site, and operational procedures throughout the assignment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assignment Details<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This is a <strong>temporary staffing assignment anticipated to last approximately three months<\/strong>. The position is scheduled to work a <strong>5x4 \/ 4x4 rotation<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assignment duration, schedule, duties, and other working conditions may be adjusted based on operational requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">About Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group provides skilled professionals to organizations across the mining, construction, and related technical industries. Our staffing team connects qualified candidates with opportunities that match their experience while supporting our clients' workforce needs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is an equal opportunity employer. We make employment decisions without regard to legally protected characteristics, in accordance with applicable law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/2d78067d3778-engineering-technician","%breezy_id%":"2d78067d3778","%breezy_friendly_id%":"2d78067d3778-engineering-technician","%breezy_created_date%":"2026-08-19T15:12:07.387Z","%breezy_updated_date%":"2026-09-08T21:53:22.731Z","%_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%":"671"}},"id":3941,"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 an Exploration Geotechnician (Core Technician) for a 3-month project supporting a surface exploration program in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geotechnician-3\/\" name=\"Geotechnician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking an Exploration Geotechnician (Core Technician) for a 3-month project supporting a surface exploration program in&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\/geotechnician-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking an Exploration Geotechnician (Core Technician) for a 3-month project supporting a surface exploration program in&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is seeking an <strong>Exploration Geotechnician (Core Technician)<\/strong> for a 3-month project supporting a surface exploration program in the Tonopah, Nevada area.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This is a hands-on, labor-focused position supporting drill core processing and organization. The role will involve cutting core with an electric core saw, moving and handling core boxes, and assisting with core photography, pXRF, and RQD activities. Candidates should be comfortable performing physical work in an active exploration environment and handling repetitive tasks safely and efficiently.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Cut drill core using an electric core saw.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Move, handle, organize, and stage core boxes.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with photographing and documenting drill core.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform or assist with pXRF activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform or assist with RQD measurements and documentation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain proper organization and handling of core throughout the process.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Keep work areas, tools, and equipment clean and organized.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safely perform repetitive, hands-on tasks throughout the shift.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow established procedures and supervisor instructions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work effectively with geologists, technicians, and other exploration personnel.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all applicable site safety requirements and work practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with other core-processing and general exploration support duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>More than 1 year of experience as a Geotechnician, Core Technician, or in a similar drill-core handling role is required.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous experience handling, processing, or cutting drill core.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comfortable using hand tools and equipment in a field or core-processing environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to safely perform physical, labor-intensive work, including regularly handling and moving core boxes.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to perform repetitive tasks while maintaining attention to safety, organization, and quality.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Basic ability to record information accurately and follow established procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Dependable, safety-conscious, and able to work effectively as part of a team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willing and able to work a rotational schedule of <strong>8 days on \/ 6 days off or 10 days on \/ 6 days off<\/strong>, depending on project needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with core photography, pXRF, or RQD is preferred but not required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assignment Details<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The position may work either an <strong>8 days on \/ 6 days off or 10 days on \/ 6 days off rotation<\/strong>, depending on project requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position is well suited for someone with previous core technician experience who enjoys hands-on work and is comfortable working in a physically active exploration environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">About Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group connects skilled professionals with opportunities across the mining, construction, and related technical industries. We partner with leading organizations to provide qualified talent for project-based and long-term workforce needs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is an equal opportunity employer. Employment decisions are made without regard to legally protected characteristics in accordance with applicable law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Geotechnician","post_link":"https:\/\/turnerstaffing.com\/position\/geotechnician-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is seeking an <strong>Exploration Geotechnician (Core Technician)<\/strong> for a 3-month project supporting a surface exploration program in the Tonopah, Nevada area.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This is a hands-on, labor-focused position supporting drill core processing and organization. The role will involve cutting core with an electric core saw, moving and handling core boxes, and assisting with core photography, pXRF, and RQD activities. Candidates should be comfortable performing physical work in an active exploration environment and handling repetitive tasks safely and efficiently.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Cut drill core using an electric core saw.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Move, handle, organize, and stage core boxes.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with photographing and documenting drill core.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform or assist with pXRF activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform or assist with RQD measurements and documentation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain proper organization and handling of core throughout the process.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Keep work areas, tools, and equipment clean and organized.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safely perform repetitive, hands-on tasks throughout the shift.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow established procedures and supervisor instructions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work effectively with geologists, technicians, and other exploration personnel.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all applicable site safety requirements and work practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with other core-processing and general exploration support duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>More than 1 year of experience as a Geotechnician, Core Technician, or in a similar drill-core handling role is required.<\/strong><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous experience handling, processing, or cutting drill core.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comfortable using hand tools and equipment in a field or core-processing environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to safely perform physical, labor-intensive work, including regularly handling and moving core boxes.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to perform repetitive tasks while maintaining attention to safety, organization, and quality.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Basic ability to record information accurately and follow established procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Dependable, safety-conscious, and able to work effectively as part of a team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willing and able to work a rotational schedule of <strong>8 days on \/ 6 days off or 10 days on \/ 6 days off<\/strong>, depending on project needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with core photography, pXRF, or RQD is preferred but not required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assignment Details<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The position may work either an <strong>8 days on \/ 6 days off or 10 days on \/ 6 days off rotation<\/strong>, depending on project requirements.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position is well suited for someone with previous core technician experience who enjoys hands-on work and is comfortable working in a physically active exploration environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Authorization<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must be <strong>authorized to work in the United States without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">About Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group connects skilled professionals with opportunities across the mining, construction, and related technical industries. We partner with leading organizations to provide qualified talent for project-based and long-term workforce needs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is an equal opportunity employer. Employment decisions are made without regard to legally protected characteristics in accordance with applicable law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/40a1bb5d5f25-geotechnician","%breezy_id%":"40a1bb5d5f25","%breezy_friendly_id%":"40a1bb5d5f25-geotechnician","%breezy_created_date%":"2026-08-19T15:27:07.139Z","%breezy_updated_date%":"2026-08-19T15:27:09.292Z","%_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%":"672"}},"id":3942,"infowindow_disable":false},{"source":"post","title":"Class B CDL Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Class B CDL Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    CDL Driver &amp; Pump Truck Operator Industry: Sand, Soil &amp; Aggregate Placement&nbsp; Employment Type: Full-Time&nbsp; Travel: Required&nbsp; About the Opportunity&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/class-b-cdl-driver\/\" name=\"Class B CDL Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"CDL Driver &amp; Pump Truck Operator Industry: Sand, Soil &amp; Aggregate Placement&nbsp; Employment Type: Full-Time&nbsp; Travel: Required&nbsp; About the Opportunity&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\/class-b-cdl-driver\/","zoom":19,"extra_fields":{"post_excerpt":"CDL Driver &amp; Pump Truck Operator Industry: Sand, Soil &amp; Aggregate Placement&nbsp; Employment Type: Full-Time&nbsp; Travel: Required&nbsp; About the Opportunity&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">CDL Driver &amp; Pump Truck Operator<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Industry: Sand, Soil &amp; Aggregate Placement&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employment Type: Full-Time&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Travel: Required&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">About the Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group has partnered with a leading company specializing in Precision Sand, Soil, &amp; Aggregate Placement. Our client delivers high-accuracy material placement for projects where precision, reliability, and a strong safety culture matter. We are seeking a skilled and dependable 10W Pump Truck Operator to join their crew and play a hands-on role in keeping operations moving across project sites.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">If you take pride in your craft, hold a valid CDL, and are ready to travel for the work, we want to hear from you.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Position Summary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The 10W Pump Truck Operator is responsible for safely operating a ten-wheel pump truck to transport and place sand, soil, and aggregate materials according to project specifications. This role combines safe driving, precise equipment operation, and a commitment to getting the job done right the first time. The position involves travel to job sites and extended periods on the road.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safely operate a 10-wheel (10W) pump truck to deliver and place sand, soil, and aggregate materials.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Position and operate pump equipment to achieve precise material placement per project requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct pre-trip and post-trip inspections; monitor vehicle and equipment condition and report maintenance needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all DOT regulations, traffic laws, and company safety policies and procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain accurate logs, delivery records, and required documentation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate with site supervisors and crew members to ensure efficient, on-spec material placement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform routine cleaning and basic upkeep of the truck and pump system.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Travel to and remain on project sites for extended periods as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid Class A or Class B Commercial Driver's License (CDL).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated pump truck operating experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong work ethic and a reliable, self-motivated approach to the job.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willingness and ability to travel for extended periods of time.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Clean driving record and ability to meet DOT requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Commitment to safety and quality on every job.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Additional heavy equipment operating experience (a strong plus).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience in aggregate, construction, or material placement environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Familiarity with precision placement techniques and project-based work.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What We Offer<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Competitive pay based on experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Steady work with a growing, specialized company.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The opportunity to work alongside an experienced, safety-focused crew.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><em>(Benefits and compensation details to be discussed during the interview process.)<\/em><\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">How to Apply<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Submit your application through Turner Staffing Group. Qualified candidates will be contacted to discuss the role, schedule, and travel expectations in more detail.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><em>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, disability, protected veteran status, or any other characteristic protected by law.<\/em><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Class B CDL Driver","post_link":"https:\/\/turnerstaffing.com\/position\/class-b-cdl-driver\/","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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">CDL Driver &amp; Pump Truck Operator<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Industry: Sand, Soil &amp; Aggregate Placement&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employment Type: Full-Time&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Travel: Required&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">About the Opportunity<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group has partnered with a leading company specializing in Precision Sand, Soil, &amp; Aggregate Placement. Our client delivers high-accuracy material placement for projects where precision, reliability, and a strong safety culture matter. We are seeking a skilled and dependable 10W Pump Truck Operator to join their crew and play a hands-on role in keeping operations moving across project sites.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">If you take pride in your craft, hold a valid CDL, and are ready to travel for the work, we want to hear from you.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Position Summary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The 10W Pump Truck Operator is responsible for safely operating a ten-wheel pump truck to transport and place sand, soil, and aggregate materials according to project specifications. This role combines safe driving, precise equipment operation, and a commitment to getting the job done right the first time. The position involves travel to job sites and extended periods on the road.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safely operate a 10-wheel (10W) pump truck to deliver and place sand, soil, and aggregate materials.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Position and operate pump equipment to achieve precise material placement per project requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct pre-trip and post-trip inspections; monitor vehicle and equipment condition and report maintenance needs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all DOT regulations, traffic laws, and company safety policies and procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain accurate logs, delivery records, and required documentation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate with site supervisors and crew members to ensure efficient, on-spec material placement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform routine cleaning and basic upkeep of the truck and pump system.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Travel to and remain on project sites for extended periods as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid Class A or Class B Commercial Driver's License (CDL).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated pump truck operating experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong work ethic and a reliable, self-motivated approach to the job.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willingness and ability to travel for extended periods of time.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Clean driving record and ability to meet DOT requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Commitment to safety and quality on every job.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Additional heavy equipment operating experience (a strong plus).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience in aggregate, construction, or material placement environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Familiarity with precision placement techniques and project-based work.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What We Offer<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Competitive pay based on experience.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Steady work with a growing, specialized company.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The opportunity to work alongside an experienced, safety-focused crew.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><em>(Benefits and compensation details to be discussed during the interview process.)<\/em><\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">How to Apply<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Submit your application through Turner Staffing Group. Qualified candidates will be contacted to discuss the role, schedule, and travel expectations in more detail.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><em>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, disability, protected veteran status, or any other characteristic protected by law.<\/em><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/c952007c3899-class-b-cdl-driver","%breezy_id%":"c952007c3899","%breezy_friendly_id%":"c952007c3899-class-b-cdl-driver","%breezy_created_date%":"2026-07-30T13:55:25.548Z","%breezy_updated_date%":"2026-07-30T13:55:27.750Z","%_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%":"661"}},"id":3931,"infowindow_disable":false},{"source":"post","title":"Construction Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Construction Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: Provide overall administrative and technical direction for one large, complex project. May direct several small and\/or medium sized&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/construction-manager\/\" name=\"Construction Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: Provide overall administrative and technical direction for one large, complex project. May direct several small and\/or medium sized&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\/construction-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: Provide overall administrative and technical direction for one large, complex project. May direct several small and\/or medium sized&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Job Summary: Provide overall administrative and technical direction for one large,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">complex project. May direct several small and\/or medium sized projects through<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">subordinate managers. Exercises ultimate authority on assigned project.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities:<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Oversee total construction effort to ensure project is constructed in accordance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">with design, budget and schedule. Includes interfacing with client representatives,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">A\/E representatives, union officials, subcontractors, security, etc.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Plan, coordinate and\/or supervise activities of all company personnel on assigned<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">project(s).<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Authorize \/ approve all project personnel transactions (hiring, transfers, wages,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">etc.), purchase requisitions, change requests, etc.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 May assist in union jurisdictional disputes and negotiations as required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Ensure all company, client, and project policies, procedures, standards, etc., are<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">adhered to. Interpret policies as required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Maintain official project log and documentation files.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Assist with implementation \/ interpretation of safety programs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Provide direction to planning, scheduling, and engineering functions as required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Perform additional assignments per supervisor's direction.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Maintain an insurable driving record.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications:<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Bachelor's degree in Civil Engineering, Construction Management, or a related field.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Minimum 10-15 years of industry experience.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Thorough knowledge of all aspects of construction (technology, equipment,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">methods, and finance); company policies, procedures and standards; and union<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">jurisdiction, labor agreements, negotiations are essential.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Superior communication and interpersonal skills essential.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Excellent organizational, supervisory and planning skills required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Skilled in assuming responsibility and reaching deadlines.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Intermediate knowledge of Microsoft Word, Excel, and Outlook<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u2022 Must be willing and able to travel.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Construction Manager","post_link":"https:\/\/turnerstaffing.com\/position\/construction-manager\/","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%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Job Summary: Provide overall administrative and technical direction for one large,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">complex project. May direct several small and\/or medium sized projects through<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">subordinate managers. Exercises ultimate authority on assigned project.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities:<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Oversee total construction effort to ensure project is constructed in accordance<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">with design, budget and schedule. Includes interfacing with client representatives,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">A\/E representatives, union officials, subcontractors, security, etc.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Plan, coordinate and\/or supervise activities of all company personnel on assigned<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">project(s).<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Authorize \/ approve all project personnel transactions (hiring, transfers, wages,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">etc.), purchase requisitions, change requests, etc.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 May assist in union jurisdictional disputes and negotiations as required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Ensure all company, client, and project policies, procedures, standards, etc., are<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">adhered to. Interpret policies as required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Maintain official project log and documentation files.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Assist with implementation \/ interpretation of safety programs.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Provide direction to planning, scheduling, and engineering functions as required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Perform additional assignments per supervisor's direction.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Maintain an insurable driving record.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications:<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Bachelor's degree in Civil Engineering, Construction Management, or a related field.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Minimum 10-15 years of industry experience.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Thorough knowledge of all aspects of construction (technology, equipment,<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">methods, and finance); company policies, procedures and standards; and union<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">jurisdiction, labor agreements, negotiations are essential.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Superior communication and interpersonal skills essential.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Excellent organizational, supervisory and planning skills required.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Skilled in assuming responsibility and reaching deadlines.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Intermediate knowledge of Microsoft Word, Excel, and Outlook<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u2022 Must be willing and able to travel.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3464b64649df-construction-manager","%breezy_id%":"3464b64649df","%breezy_friendly_id%":"3464b64649df-construction-manager","%breezy_created_date%":"2026-07-30T17:52:15.462Z","%breezy_updated_date%":"2026-07-31T14:21:32.825Z","%_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","%rank_math_analytic_object_id%":"662"}},"id":3932,"infowindow_disable":false},{"source":"post","title":"Construction Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Construction Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview Turner Staffing Group is seeking experienced Underground Construction Supervisors to support a major underground decline infrastructure project for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/construction-supervisor\/\" name=\"Construction Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview Turner Staffing Group is seeking experienced Underground Construction Supervisors to support a major underground decline infrastructure project for&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\/construction-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview Turner Staffing Group is seeking experienced Underground Construction Supervisors to support a major underground decline infrastructure project for&hellip;","post_content":"<p style=\"font-family:Arial;font-size:16px;margin:0px\">Position Overview<\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is seeking experienced <strong>Underground Construction Supervisors<\/strong> to support a major underground decline infrastructure project for a new mine development. This role will oversee underground construction activities, ensuring work is completed safely, efficiently, and in accordance with project schedules and quality standards. Project length is expected to be 6-8 months in length.<\/p><p style=\"font-family:Arial;font-size:16px;margin:0px;line-height:1.5\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px;line-height:1.5\"><span style=\"font-family:Arial;font-size:16px\">Schedule: Ideally, 5 days on\/4 off. Will consider other rotations for the right candidate. <\/span><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>Company-provided truck or transportation<\/span><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>Cell phone<\/span><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>Laptop<\/span><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><span>Additional project resources provided as required<\/span><\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;margin:0px;line-height:1.5\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Candidates with <strong>startup mine construction experience<\/strong> are strongly preferred.<\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Supervise underground decline and infrastructure construction activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Spend significant time in the field providing visible leadership and supporting crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Lead daily safety efforts, including job hazard analyses, field-level risk assessments, and incident follow-up.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure compliance with all safety, environmental, and operational standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop and execute weekly construction plans in coordination with project leadership.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prioritize work activities to meet project milestones and production goals.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct quality inspections and monitor construction progress.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in daily coordination meetings and weekly planning sessions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support workforce development through coaching, performance management, and mentoring.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with continuous improvement initiatives and construction process optimization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate with project stakeholders to ensure materials, equipment, and labor resources are available.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">5-10 years of underground construction experience, preferably in mining.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Minimum of 2 years of supervisory experience in an underground environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience managing underground decline or mine infrastructure construction projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Startup mine development experience strongly preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong leadership, planning, and communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Commitment to safe work practices and field leadership.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;margin:0px\">Preferred Experience<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Underground mine construction startup projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Heavy civil or underground infrastructure construction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Scheduling and coordinating multiple construction crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Working in remote mining environments and rotational schedules.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;margin:0px\">Additional Information<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Relocation assistance is negotiable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Opportunity for permanent conversion may exist, but is not expected.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Immediate project beginning in August.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>Work Authorization:<\/strong> Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Construction Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/construction-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%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=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Position Overview<\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is seeking experienced <strong>Underground Construction Supervisors<\/strong> to support a major underground decline infrastructure project for a new mine development. This role will oversee underground construction activities, ensuring work is completed safely, efficiently, and in accordance with project schedules and quality standards. Project length is expected to be 6-8 months in length.<\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;line-height:1.5;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;line-height:1.5;\"><span style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);\">Schedule: Ideally, 5 days on\/4 off. Will consider other rotations for the right candidate. <\/span><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">Company-provided truck or transportation<\/span><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">Cell phone<\/span><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">Laptop<\/span><\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><span style=\"color:rgb(0, 0, 0);\">Additional project resources provided as required<\/span><\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;line-height:1.5;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates with <strong>startup mine construction experience<\/strong> are strongly preferred.<\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Supervise underground decline and infrastructure construction activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Spend significant time in the field providing visible leadership and supporting crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Lead daily safety efforts, including job hazard analyses, field-level risk assessments, and incident follow-up.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure compliance with all safety, environmental, and operational standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop and execute weekly construction plans in coordination with project leadership.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prioritize work activities to meet project milestones and production goals.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct quality inspections and monitor construction progress.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in daily coordination meetings and weekly planning sessions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support workforce development through coaching, performance management, and mentoring.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with continuous improvement initiatives and construction process optimization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate with project stakeholders to ensure materials, equipment, and labor resources are available.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">5-10 years of underground construction experience, preferably in mining.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Minimum of 2 years of supervisory experience in an underground environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience managing underground decline or mine infrastructure construction projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Startup mine development experience strongly preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong leadership, planning, and communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Commitment to safe work practices and field leadership.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Experience<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Underground mine construction startup projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Heavy civil or underground infrastructure construction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Scheduling and coordinating multiple construction crews.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Working in remote mining environments and rotational schedules.<\/li>\n<\/ul><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Additional Information<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Relocation assistance is negotiable.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Opportunity for permanent conversion may exist, but is not expected.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Immediate project beginning in August.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Work Authorization:<\/strong> Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/7b149c267a0c-construction-supervisor","%breezy_id%":"7b149c267a0c","%breezy_friendly_id%":"7b149c267a0c-construction-supervisor","%breezy_created_date%":"2026-07-30T18:48:37.190Z","%breezy_updated_date%":"2026-07-30T18:48:39.848Z","%_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%":"663"}},"id":3933,"infowindow_disable":false},{"source":"post","title":"Screed Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Screed Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is looking for a Paving Screed Operator who will be responsible for operating and controlling the screed on&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/screed-operator\/\" name=\"Screed Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is looking for a Paving Screed Operator who will be responsible for operating and controlling the screed on&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\/screed-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is looking for a Paving Screed Operator who will be responsible for operating and controlling the screed on&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Our client is looking for a Paving Screed Operator who will be 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate the screed controls on an asphalt paver to regulate depth, width, and smoothness of the asphalt mat<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Adjust screed settings to maintain proper grade, slope, and crown according to project plans<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Monitor asphalt material flow and temperature to ensure consistent paving quality<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate with the paver operator, roller operators, and ground crew for efficient workflow<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform routine checks and minor maintenance on screed equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify and correct surface irregularities during paving operations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure compliance with safety regulations and company policies<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Read and interpret project plans, grade stakes, and specifications<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain a safe and clean work environment<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High school diploma or equivalent preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">2+ years of experience operating paving equipment, specifically screeds<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of asphalt paving processes and materials<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to read grade stakes, blueprints, and layout drawings<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver\u2019s license (CDL preferred but not always required)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Skills &amp; Competencies<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Attention to detail and precision in equipment operation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong hand-eye coordination<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work effectively in a team environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Good communication and problem-solving skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Mechanical aptitude for equipment troubleshooting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in varying weather conditions<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical Requirements<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to stand for long periods and work on uneven surfaces<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Frequently lift up to 50 lbs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work outdoors in hot, cold, and noisy environments<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must be able to bend, stoop, and climb onto equipment<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This role is based in Bowmansville, PA and is an on-site role.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Screed Operator","post_link":"https:\/\/turnerstaffing.com\/position\/screed-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%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Our client is looking for a Paving Screed Operator who will be 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate the screed controls on an asphalt paver to regulate depth, width, and smoothness of the asphalt mat<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Adjust screed settings to maintain proper grade, slope, and crown according to project plans<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Monitor asphalt material flow and temperature to ensure consistent paving quality<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate with the paver operator, roller operators, and ground crew for efficient workflow<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform routine checks and minor maintenance on screed equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify and correct surface irregularities during paving operations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure compliance with safety regulations and company policies<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Read and interpret project plans, grade stakes, and specifications<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain a safe and clean work environment<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High school diploma or equivalent preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">2+ years of experience operating paving equipment, specifically screeds<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of asphalt paving processes and materials<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to read grade stakes, blueprints, and layout drawings<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver\u2019s license (CDL preferred but not always required)<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Skills &amp; Competencies<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Attention to detail and precision in equipment operation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong hand-eye coordination<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work effectively in a team environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Good communication and problem-solving skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Mechanical aptitude for equipment troubleshooting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in varying weather conditions<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical Requirements<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to stand for long periods and work on uneven surfaces<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Frequently lift up to 50 lbs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work outdoors in hot, cold, and noisy environments<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must be able to bend, stoop, and climb onto equipment<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This role is based in Bowmansville, PA and is an on-site role.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3ebcfc7abc45-screed-operator","%breezy_id%":"3ebcfc7abc45","%breezy_friendly_id%":"3ebcfc7abc45-screed-operator","%breezy_created_date%":"2026-08-04T18:06:39.751Z","%breezy_updated_date%":"2026-08-04T18:06:46.108Z","%_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%":"664"}},"id":3934,"infowindow_disable":false},{"source":"post","title":"Senior Supply Chain Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Supply Chain Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is recruiting a Sr. Supply Chain Specialist for a permanent opportunity with our client in the Republic,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-supply-chain-specialist\/\" name=\"Senior Supply Chain Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is recruiting a Sr. Supply Chain Specialist for a permanent opportunity with our client in the Republic,&hellip;","address":"Republic, WA, USA","location":{"lat":"48.6482183","city":"Republic","state":"WA","country":"United States","lng":"-118.7378067","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-supply-chain-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is recruiting a Sr. Supply Chain Specialist for a permanent opportunity with our client in the Republic,&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is recruiting a <strong>Sr. Supply Chain Specialist<\/strong> for a permanent opportunity with our client in the Republic, Washington area.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This is an opportunity to join an established mining organization operating in the rural landscapes of Washington State. The operation manages properties across various stages of exploration, development, care and maintenance, and closure, with a strong emphasis on safety, environmental stewardship, and responsible resource management.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Position Overview<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reporting to the <strong>Supply Chain Superintendent<\/strong>, the Sr. Supply Chain Specialist will lead and support procurement activities with a strong emphasis on <strong>contract development, negotiation, administration, and strategic vendor management<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position plays an important role in supporting operational efficiency, cost control, supplier performance, and supply chain risk management. The ideal candidate brings significant procurement and commercial contracting experience, preferably within mining, heavy industry, oil &amp; gas, or a similar industrial environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop, draft, negotiate, and administer commercial contracts in accordance with company policies and business requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Lead and support vendor negotiations involving pricing, delivery terms, warranties, service levels, commercial terms, and risk mitigation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prepare and issue Requests for Quotation (RFQs), Requests for Proposal (RFPs), and competitive bid packages.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Evaluate vendor proposals and provide recommendations for contract awards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Partner with legal, operations, project, and supply chain teams to develop clear, effective agreements that support long-term business value.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Monitor supplier performance and compliance with contractual requirements and assist in resolving performance issues and disputes.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain accurate procurement, sourcing, and contract documentation to support internal controls, audits, and compliance requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop and maintain productive supplier relationships while promoting competitive pricing, service quality, and overall value.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify opportunities for cost savings, process improvements, and supply chain risk mitigation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Monitor market conditions, supplier performance, and sourcing trends to support informed procurement decisions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform additional duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Bachelor\u2019s degree in Business Administration, Supply Chain Management, or a related discipline preferred; equivalent relevant experience will be considered.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>5\u20138 years of procurement experience<\/strong>, including significant experience with contract development and commercial negotiations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated ability to draft, negotiate, and administer commercial contracts.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong knowledge of procurement processes, commercial contract principles, and supplier performance management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience in <strong>mining, heavy industry, oil &amp; gas, or another industrial environment<\/strong> is preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience working with ERP systems and procurement software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong analytical, organizational, communication, and stakeholder-management skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work collaboratively across operations, projects, legal, and other business functions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver\u2019s license required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Health, Safety &amp; Environmental Expectations<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety and environmental responsibility are fundamental to this position. The Sr. Supply Chain Specialist is expected to:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrate a strong commitment to safe working practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow established safety, environmental, and operating procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comply with applicable regulatory requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Wear required Personal Protective Equipment (PPE) when entering designated production or operational environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Remain alert to workplace hazards and appropriately identify, correct, and report unsafe conditions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support a workplace culture where employees return home safe and healthy every day.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Leadership &amp; Business Practices<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Successful candidates will demonstrate the ability to:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Treat employees, suppliers, contractors, and stakeholders with professionalism and respect.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Build collaborative relationships and bring teams together to accomplish organizational objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Take accountability for decisions, commitments, and results.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Exercise sound judgment when balancing competing priorities and business requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Use company resources effectively and efficiently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support strong environmental performance and positive community and stakeholder relationships.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify, promote, and implement supply chain and procurement best practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Contribute to an environment that supports employee development and continuous improvement.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The client offers a benefits package that includes:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Medical, dental, and vision insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">401(k) with company match<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Paid time off<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Stock purchase option<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Basic life insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Short-term incentive opportunity<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Compensation will be based on experience, qualifications, and the requirements of the position.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">About Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is partnering with our client to identify qualified candidates for this <strong>permanent, direct-hire opportunity<\/strong>. Our recruiting team works with candidates throughout the hiring process to help connect experienced professionals with career opportunities across the mining and heavy industrial sectors.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group and its clients are committed to providing equal employment opportunities in accordance with applicable federal, state, and local laws.<\/p>","post_title":"Senior Supply Chain Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/senior-supply-chain-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Republic","%location_state_id%":"WA","%location_state_name%":"Washington","%location_city_state%":"Republic, WA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is recruiting a <strong>Sr. Supply Chain Specialist<\/strong> for a permanent opportunity with our client in the Republic, Washington area.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This is an opportunity to join an established mining organization operating in the rural landscapes of Washington State. The operation manages properties across various stages of exploration, development, care and maintenance, and closure, with a strong emphasis on safety, environmental stewardship, and responsible resource management.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Position Overview<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reporting to the <strong>Supply Chain Superintendent<\/strong>, the Sr. Supply Chain Specialist will lead and support procurement activities with a strong emphasis on <strong>contract development, negotiation, administration, and strategic vendor management<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position plays an important role in supporting operational efficiency, cost control, supplier performance, and supply chain risk management. The ideal candidate brings significant procurement and commercial contracting experience, preferably within mining, heavy industry, oil &amp; gas, or a similar industrial environment.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop, draft, negotiate, and administer commercial contracts in accordance with company policies and business requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Lead and support vendor negotiations involving pricing, delivery terms, warranties, service levels, commercial terms, and risk mitigation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prepare and issue Requests for Quotation (RFQs), Requests for Proposal (RFPs), and competitive bid packages.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Evaluate vendor proposals and provide recommendations for contract awards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Partner with legal, operations, project, and supply chain teams to develop clear, effective agreements that support long-term business value.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Monitor supplier performance and compliance with contractual requirements and assist in resolving performance issues and disputes.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain accurate procurement, sourcing, and contract documentation to support internal controls, audits, and compliance requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop and maintain productive supplier relationships while promoting competitive pricing, service quality, and overall value.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify opportunities for cost savings, process improvements, and supply chain risk mitigation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Monitor market conditions, supplier performance, and sourcing trends to support informed procurement decisions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform additional duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Bachelor\u2019s degree in Business Administration, Supply Chain Management, or a related discipline preferred; equivalent relevant experience will be considered.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>5\u20138 years of procurement experience<\/strong>, including significant experience with contract development and commercial negotiations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated ability to draft, negotiate, and administer commercial contracts.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong knowledge of procurement processes, commercial contract principles, and supplier performance management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience in <strong>mining, heavy industry, oil &amp; gas, or another industrial environment<\/strong> is preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience working with ERP systems and procurement software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong analytical, organizational, communication, and stakeholder-management skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work collaboratively across operations, projects, legal, and other business functions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver\u2019s license required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Health, Safety &amp; Environmental Expectations<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety and environmental responsibility are fundamental to this position. The Sr. Supply Chain Specialist is expected to:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrate a strong commitment to safe working practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow established safety, environmental, and operating procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comply with applicable regulatory requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Wear required Personal Protective Equipment (PPE) when entering designated production or operational environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Remain alert to workplace hazards and appropriately identify, correct, and report unsafe conditions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support a workplace culture where employees return home safe and healthy every day.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Leadership &amp; Business Practices<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Successful candidates will demonstrate the ability to:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Treat employees, suppliers, contractors, and stakeholders with professionalism and respect.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Build collaborative relationships and bring teams together to accomplish organizational objectives.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Take accountability for decisions, commitments, and results.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Exercise sound judgment when balancing competing priorities and business requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Use company resources effectively and efficiently.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support strong environmental performance and positive community and stakeholder relationships.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify, promote, and implement supply chain and procurement best practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Contribute to an environment that supports employee development and continuous improvement.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The client offers a benefits package that includes:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Medical, dental, and vision insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">401(k) with company match<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Paid time off<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Stock purchase option<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Basic life insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Short-term incentive opportunity<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Compensation will be based on experience, qualifications, and the requirements of the position.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">About Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is partnering with our client to identify qualified candidates for this <strong>permanent, direct-hire opportunity<\/strong>. Our recruiting team works with candidates throughout the hiring process to help connect experienced professionals with career opportunities across the mining and heavy industrial sectors.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group and its clients are committed to providing equal employment opportunities in accordance with applicable federal, state, and local laws.<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/52496a753731-senior-supply-chain-specialist","%breezy_id%":"52496a753731","%breezy_friendly_id%":"52496a753731-senior-supply-chain-specialist","%breezy_created_date%":"2026-08-08T12:36:05.615Z","%breezy_updated_date%":"2026-08-08T12:36:07.796Z","%_wpgmp_location_city%":"Republic","%_wpgmp_location_state%":"WA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Republic, WA, USA","%_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","%rank_math_analytic_object_id%":"665"}},"id":3935,"infowindow_disable":false},{"source":"post","title":"Mine Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Mine Supervisor Upstate New York&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;40 Hours\/Week&nbsp;|&nbsp;On-Site Reports to: General Manager Turner Staffing Group is partnering with our client, an established&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-supervisor\/\" name=\"Mine Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mine Supervisor Upstate New York&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;40 Hours\/Week&nbsp;|&nbsp;On-Site Reports to: General Manager Turner Staffing Group is partnering with our client, an established&hellip;","address":"Gouverneur, NY, USA","location":{"lat":"44.3367281","city":"Gouverneur","state":"NY","country":"United States","lng":"-75.462993","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Mine Supervisor Upstate New York&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;40 Hours\/Week&nbsp;|&nbsp;On-Site Reports to: General Manager Turner Staffing Group is partnering with our client, an established&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Mine Supervisor<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Upstate New York&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;40 Hours\/Week&nbsp;|&nbsp;On-Site<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><em>Reports to: General Manager<\/em><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is partnering with our client, an established mining company based in New York, to find an experienced Mine Supervisor to lead day-to-day underground mining operations. This is a hands-on leadership role for someone who takes pride in running a safe, efficient, and well-organized operation, and who wants real ownership over production, safety, and team performance.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><u>What You'll Do<\/u><\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Operations &amp; Production<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf    &nbsp;&nbsp;Supervise and coordinate all aspects of daily underground mining operations.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Plan and schedule ore extraction, waste removal, and preventive maintenance to keep pace with mill demand.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Coordinate trucking and mine-mill activities to keep production flowing smoothly.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Direct underground blasting and maintain accurate records of explosives usage.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Oversee maintenance of drilling, hauling, loading, and crushing equipment.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Safety &amp; Compliance<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain and champion a strong safety program, training personnel on safe work practices.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Perform regular site inspections and assess the safety of sidewalls, drifts, pillars, and benches.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ensure sound housekeeping practices throughout the mine site.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Team Leadership &amp; Reporting<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Train and develop hourly personnel, building a skilled and reliable crew.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain production, maintenance, and time-distribution records, and prepare monthly operational reports.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Provide payroll data and support Collective Bargaining Agreement activities.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Investigate and recommend new mining procedures, equipment, and alternate ore sources to improve efficiency.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Report regularly to the General Manager on department performance, condition, and findings.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Bring<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;High school diploma or equivalent.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;3-5 years of experience in a similar mining operation, including at least 1 year in a supervisory role.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;New York State DOL Blasting License is a plus.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong working knowledge of mine safety, production planning, and equipment maintenance.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;A proactive, hands-on leadership style with sound judgment for day-to-day and emergency decisions.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Comfort working both underground and on the surface in a physically active, industrial environment.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Why This Role<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Step into a role with real autonomy - routine decisions are trusted to you, not micromanaged.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Play a key part in shaping mine planning, safety culture, and operational efficiency.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work daily alongside the General Manager and a dedicated production team.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Join a stable, established operation with room to make your mark.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Interested in learning more?<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Apply today through Turner Staffing Group to be considered for this opportunity with our client.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Mine Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/mine-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Gouverneur","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Gouverneur, NY","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Mine Supervisor<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Upstate New York&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;40 Hours\/Week&nbsp;|&nbsp;On-Site<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><em>Reports to: General Manager<\/em><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is partnering with our client, an established mining company based in New York, to find an experienced Mine Supervisor to lead day-to-day underground mining operations. This is a hands-on leadership role for someone who takes pride in running a safe, efficient, and well-organized operation, and who wants real ownership over production, safety, and team performance.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><u>What You'll Do<\/u><\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Operations &amp; Production<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf    &nbsp;&nbsp;Supervise and coordinate all aspects of daily underground mining operations.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Plan and schedule ore extraction, waste removal, and preventive maintenance to keep pace with mill demand.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Coordinate trucking and mine-mill activities to keep production flowing smoothly.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Direct underground blasting and maintain accurate records of explosives usage.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Oversee maintenance of drilling, hauling, loading, and crushing equipment.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Safety &amp; Compliance<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain and champion a strong safety program, training personnel on safe work practices.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Perform regular site inspections and assess the safety of sidewalls, drifts, pillars, and benches.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ensure sound housekeeping practices throughout the mine site.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Team Leadership &amp; Reporting<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Train and develop hourly personnel, building a skilled and reliable crew.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain production, maintenance, and time-distribution records, and prepare monthly operational reports.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Provide payroll data and support Collective Bargaining Agreement activities.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Investigate and recommend new mining procedures, equipment, and alternate ore sources to improve efficiency.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Report regularly to the General Manager on department performance, condition, and findings.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Bring<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;High school diploma or equivalent.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;3-5 years of experience in a similar mining operation, including at least 1 year in a supervisory role.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;New York State DOL Blasting License is a plus.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong working knowledge of mine safety, production planning, and equipment maintenance.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;A proactive, hands-on leadership style with sound judgment for day-to-day and emergency decisions.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Comfort working both underground and on the surface in a physically active, industrial environment.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Why This Role<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Step into a role with real autonomy - routine decisions are trusted to you, not micromanaged.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Play a key part in shaping mine planning, safety culture, and operational efficiency.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work daily alongside the General Manager and a dedicated production team.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Join a stable, established operation with room to make your mark.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Interested in learning more?<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Apply today through Turner Staffing Group to be considered for this opportunity with our client.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/03e597964e08-mine-supervisor","%breezy_id%":"03e597964e08","%breezy_friendly_id%":"03e597964e08-mine-supervisor","%breezy_created_date%":"2026-07-21T15:23:17.352Z","%breezy_updated_date%":"2026-07-23T15:26:14.813Z","%_wpgmp_location_city%":"Gouverneur","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gouverneur, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"44.3367281","%_wpgmp_metabox_longitude%":"-75.462993","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"653"}},"id":3923,"infowindow_disable":false},{"source":"post","title":"Laboratory Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Laboratory Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Laboratory Technician Kershaw, SC&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site Reports to: Shift Supervisor Turner Staffing Group is partnering with our client, a minerals testing laboratory&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/laboratory-technician\/\" name=\"Laboratory Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Laboratory Technician Kershaw, SC&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site Reports to: Shift Supervisor Turner Staffing Group is partnering with our client, a minerals testing laboratory&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\/laboratory-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Laboratory Technician Kershaw, SC&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site Reports to: Shift Supervisor Turner Staffing Group is partnering with our client, a minerals testing laboratory&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Laboratory Technician<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Kershaw, SC&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><em>Reports to: Shift Supervisor<\/em><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is partnering with our client, a minerals testing laboratory in Kershaw, SC, to find a detail-oriented Laboratory Technician. In this role, you'll process client samples from preparation through analysis, playing a hands-on part in delivering accurate, high-quality results in a fast-paced lab environment. This is a great opportunity for someone who enjoys precise, methodical work and wants to build a career in laboratory and minerals testing operations.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong><u>What You'll Do<\/u><\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Sample Processing &amp; Analysis<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf    &nbsp;&nbsp;Prepare and process samples using approved digestion and dissolution methods, following documented lab procedures.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Perform primary crushing, riffle splitting, subsampling, sieving, compositing, and racking of samples.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Operate laboratory equipment, including Orbis crushers and LM2 pulverisers, in line with training and safe work procedures.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Accurately weigh and prepare samples for a range of analytical testing methods.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work independently once trained, managing multiple jobs to meet operational priorities and deadlines.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Quality &amp; Recordkeeping<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain accurate laboratory worksheets and update spreadsheets and tracking systems.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Support quality control efforts and escalate non-conformances following lab procedures.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Keep quality records current and aligned with the lab's quality management system.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Perform routine housekeeping and equipment maintenance to keep the lab clean and contamination-free.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Safety &amp; Team Collaboration<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Participate in daily pre-start meetings, shift handovers, and safety discussions.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Follow all safety procedures and correctly use personal protective equipment (PPE).<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Identify and report hazards, and take appropriate action to reduce risk.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Support and mentor teammates, sharing knowledge as your experience grows.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Bring<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;High school diploma \/ Year 12 certificate or equivalent.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Prior experience in a minerals or analytical laboratory preferred, including sample preparation and lab data entry.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Familiarity with laboratory procedures, standards, and quality systems.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong attention to detail and solid basic lab bench skills, including accurate pipetting and contamination prevention.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Basic to intermediate Microsoft Excel and Word skills for recordkeeping and reporting.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong communication skills and the ability to work well within a team.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Valid driver's license; forklift license a plus.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Comfortable working in a remote-site or rotating-roster laboratory environment.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Why This Role<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Build hands-on experience in a specialized minerals testing laboratory.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work with modern lab equipment and gain exposure to industry-standard quality systems.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Grow into more advanced technical and leadership responsibilities as you develop your skills.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Join a collaborative team environment with a strong focus on safety and quality.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Interested in learning more?<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Apply today through Turner Staffing Group to be considered for this opportunity with our client.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Laboratory Technician","post_link":"https:\/\/turnerstaffing.com\/position\/laboratory-technician\/","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%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Laboratory Technician<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Kershaw, SC&nbsp;|&nbsp;Full-Time&nbsp;|&nbsp;On-Site<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><em>Reports to: Shift Supervisor<\/em><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is partnering with our client, a minerals testing laboratory in Kershaw, SC, to find a detail-oriented Laboratory Technician. In this role, you'll process client samples from preparation through analysis, playing a hands-on part in delivering accurate, high-quality results in a fast-paced lab environment. This is a great opportunity for someone who enjoys precise, methodical work and wants to build a career in laboratory and minerals testing operations.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong><u>What You'll Do<\/u><\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Sample Processing &amp; Analysis<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf    &nbsp;&nbsp;Prepare and process samples using approved digestion and dissolution methods, following documented lab procedures.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Perform primary crushing, riffle splitting, subsampling, sieving, compositing, and racking of samples.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Operate laboratory equipment, including Orbis crushers and LM2 pulverisers, in line with training and safe work procedures.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Accurately weigh and prepare samples for a range of analytical testing methods.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work independently once trained, managing multiple jobs to meet operational priorities and deadlines.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Quality &amp; Recordkeeping<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain accurate laboratory worksheets and update spreadsheets and tracking systems.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Support quality control efforts and escalate non-conformances following lab procedures.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Keep quality records current and aligned with the lab's quality management system.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Perform routine housekeeping and equipment maintenance to keep the lab clean and contamination-free.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Safety &amp; Team Collaboration<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Participate in daily pre-start meetings, shift handovers, and safety discussions.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Follow all safety procedures and correctly use personal protective equipment (PPE).<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Identify and report hazards, and take appropriate action to reduce risk.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Support and mentor teammates, sharing knowledge as your experience grows.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Bring<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;High school diploma \/ Year 12 certificate or equivalent.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Prior experience in a minerals or analytical laboratory preferred, including sample preparation and lab data entry.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Familiarity with laboratory procedures, standards, and quality systems.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong attention to detail and solid basic lab bench skills, including accurate pipetting and contamination prevention.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Basic to intermediate Microsoft Excel and Word skills for recordkeeping and reporting.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong communication skills and the ability to work well within a team.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Valid driver's license; forklift license a plus.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Comfortable working in a remote-site or rotating-roster laboratory environment.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Why This Role<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Build hands-on experience in a specialized minerals testing laboratory.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work with modern lab equipment and gain exposure to industry-standard quality systems.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Grow into more advanced technical and leadership responsibilities as you develop your skills.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u25cf&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Join a collaborative team environment with a strong focus on safety and quality.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Interested in learning more?<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Apply today through Turner Staffing Group to be considered for this opportunity with our client.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b4c9136b6150-laboratory-technician","%breezy_id%":"b4c9136b6150","%breezy_friendly_id%":"b4c9136b6150-laboratory-technician","%breezy_created_date%":"2026-07-22T12:50:22.588Z","%breezy_updated_date%":"2026-07-23T15:12:54.231Z","%_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","%rank_math_analytic_object_id%":"654"}},"id":3924,"infowindow_disable":false},{"source":"post","title":"Sample Preparer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Sample Preparer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    1.&nbsp;&nbsp;&nbsp;POSITION PURPOSE &nbsp; The primary purpose of this role is to prepare samples accurately and efficiently according to approved procedures,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/sample-preparer\/\" name=\"Sample Preparer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"1.&nbsp;&nbsp;&nbsp;POSITION PURPOSE &nbsp; The primary purpose of this role is to prepare samples accurately and efficiently according to approved procedures,&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\/sample-preparer\/","zoom":19,"extra_fields":{"post_excerpt":"1.&nbsp;&nbsp;&nbsp;POSITION PURPOSE &nbsp; The primary purpose of this role is to prepare samples accurately and efficiently according to approved procedures,&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>1.&nbsp;&nbsp;&nbsp;POSITION PURPOSE &nbsp;<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong> <\/strong>The primary purpose of this role is to prepare samples accurately and efficiently according to approved procedures, and in a safe and efficient manner to achieve a quality product.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>2. KEY RESPONSIBILITIES AND ACCOUNTABILITIES (included and not limited to): <\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>2.1 Technical\/Functional<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7    &nbsp;&nbsp;&nbsp;&nbsp;Sort and weigh samples<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Rotate sample trolleys in and out of drying ovens<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Safely operate machinery to crush, split and pulverise samples, as directed by the Shift Supervisor<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Report any quality, production or safety issues<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work efficiently to achieve a consistent level of production<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Recognize basic quality deviations<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ensure accurate sample reconciliation and chain of custody is maintained. Immediately report any anomalies to the supervisor\/manager<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work in accordance with standard production procedures.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Perform housekeeping and keep a tidy work area<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Participate in daily pre-start meetings, shift handovers, Safety meetings <\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Complete all tasks with a high degree of care and attention to detail to ensure sample integrity<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Demonstrate effective communication skills and integration into the team<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Other appropriate duties as instructed by the Shift Supervisor.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>2.2 Occupational Health, Safety &amp; Environment (OHSE)<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Be responsible for complying with OHSE requirements and contributing to the creation and maintenance of a healthy and safe work environment.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Comply with all applicable work instructions, work procedures, safe work procedures, safe work instructions, and lawful directions provided by the supervisor, whether written or verbal.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Correctly wear, maintain, and dispose of personal protective equipment in accordance with requirements.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Identify and promptly report safety hazards, and take reasonable action to mitigate risks to an acceptable level where it is safe to do so.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain a high standard of housekeeping within the work area.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Take reasonable care for their own psychological and physical health and safety, and that of others who may be affected by their acts or omissions.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Exercise the authority to stop a task or operation where an imminent and serious risk to people, property, or the environment is identified, and immediately escalate the matter to a supervisor.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Participate in risk management activities, including the completion of risk assessments and hazard controls.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Report all OHSE incidents, injuries, and near misses to the supervisor as soon as practicable.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Cooperate with all reasonable safety and health policies, procedures, and initiatives implemented by the Employer.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Take reasonable care of plant, equipment, and tools, ensuring they are used correctly and not misused or damaged.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Participate in safety meetings, toolbox talks, and other OHSE-related training or consultations as required.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>2.3 Other<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The ability to perform manual handling and lift up to 20kg with repetition safely.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The right to work and live in Australia.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>1.&nbsp;&nbsp;&nbsp;POSITION REQUIREMENTS<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>3.1 Education &amp; Qualifications<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The completion of at least year 10 or equivalent<\/li><\/ul>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>3.2 Knowledge &amp; Experience<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Demonstrated commitment to workplace health and safety<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Previous experience in sample preparation desirable. <\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>3.3 Skills &amp; Abilities<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to safely perform manual handling tasks, including standing for extended periods and regularly lifting items weighing approximately 15\u201320 kg, in accordance with safe work practices.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Effective verbal and written communication skills suitable for a laboratory and production environment.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to work independently once trained, while managing a fluctuating workload and changing priorities.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Capacity to work effectively in a fast-paced operational environment while maintaining safety and quality standards.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong practical problem-solving skills with sound mechanical aptitude relevant to sample preparation equipment.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to work cooperatively as part of a team to support operational and production requirements.<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>3.4 Other<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Driver\u2019s License<\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>2.&nbsp;&nbsp;&nbsp;COMPANY GLOBAL REQUIREMENTS<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>4.1 Leadership<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Lead by example, comply with all legal, professional and company requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide guidance to colleagues and through them the business line to maintain engagement in the company\u2019s vision and strategy, build a capable workforce and provide a work environment in which people can perform.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide leadership through promoting and creating buy in for a 10x culture and 5x5 strategy.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure that systems are utilised and maintained as required. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure that effective communication methods are adopted throughout the team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure that HR policies and procedures are followed at all times.<\/li>\n<\/ul>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>4.2 Team focus<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in formal and informal team communication activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in the development and achievement of team goals and workload requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Contribute to the development of new and innovative processes and practices.<\/li>\n<\/ul>\n<p style=\"font-family:Arial;font-size:16px;margin:0px\"><strong>4.3 Other<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Other appropriate duties as requested by your Employer.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">You must have the right to live and work in this location to apply for this job. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Actively participate in the management and compliance of company Country and Global safety policies, procedures and requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comply with all company policies and procedures, including: HR, IT, quality and operations.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Sample Preparer","post_link":"https:\/\/turnerstaffing.com\/position\/sample-preparer\/","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%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>1.&nbsp;&nbsp;&nbsp;POSITION PURPOSE &nbsp;<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong> <\/strong>The primary purpose of this role is to prepare samples accurately and efficiently according to approved procedures, and in a safe and efficient manner to achieve a quality product.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>2. KEY RESPONSIBILITIES AND ACCOUNTABILITIES (included and not limited to): <\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>2.1 Technical\/Functional<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7    &nbsp;&nbsp;&nbsp;&nbsp;Sort and weigh samples<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Rotate sample trolleys in and out of drying ovens<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Safely operate machinery to crush, split and pulverise samples, as directed by the Shift Supervisor<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Report any quality, production or safety issues<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work efficiently to achieve a consistent level of production<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Recognize basic quality deviations<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ensure accurate sample reconciliation and chain of custody is maintained. Immediately report any anomalies to the supervisor\/manager<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Work in accordance with standard production procedures.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Perform housekeeping and keep a tidy work area<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Participate in daily pre-start meetings, shift handovers, Safety meetings <\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Complete all tasks with a high degree of care and attention to detail to ensure sample integrity<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Demonstrate effective communication skills and integration into the team<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Other appropriate duties as instructed by the Shift Supervisor.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>2.2 Occupational Health, Safety &amp; Environment (OHSE)<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Be responsible for complying with OHSE requirements and contributing to the creation and maintenance of a healthy and safe work environment.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Comply with all applicable work instructions, work procedures, safe work procedures, safe work instructions, and lawful directions provided by the supervisor, whether written or verbal.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Correctly wear, maintain, and dispose of personal protective equipment in accordance with requirements.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Identify and promptly report safety hazards, and take reasonable action to mitigate risks to an acceptable level where it is safe to do so.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Maintain a high standard of housekeeping within the work area.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Take reasonable care for their own psychological and physical health and safety, and that of others who may be affected by their acts or omissions.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Exercise the authority to stop a task or operation where an imminent and serious risk to people, property, or the environment is identified, and immediately escalate the matter to a supervisor.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Participate in risk management activities, including the completion of risk assessments and hazard controls.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Report all OHSE incidents, injuries, and near misses to the supervisor as soon as practicable.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Cooperate with all reasonable safety and health policies, procedures, and initiatives implemented by the Employer.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Take reasonable care of plant, equipment, and tools, ensuring they are used correctly and not misused or damaged.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Participate in safety meetings, toolbox talks, and other OHSE-related training or consultations as required.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>2.3 Other<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The ability to perform manual handling and lift up to 20kg with repetition safely.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;The right to work and live in Australia.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>1.&nbsp;&nbsp;&nbsp;POSITION REQUIREMENTS<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>3.1 Education &amp; Qualifications<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The completion of at least year 10 or equivalent<\/li><\/ul>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>3.2 Knowledge &amp; Experience<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Demonstrated commitment to workplace health and safety<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Previous experience in sample preparation desirable. <\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>3.3 Skills &amp; Abilities<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to safely perform manual handling tasks, including standing for extended periods and regularly lifting items weighing approximately 15\u201320 kg, in accordance with safe work practices.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Effective verbal and written communication skills suitable for a laboratory and production environment.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to work independently once trained, while managing a fluctuating workload and changing priorities.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Capacity to work effectively in a fast-paced operational environment while maintaining safety and quality standards.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strong practical problem-solving skills with sound mechanical aptitude relevant to sample preparation equipment.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to work cooperatively as part of a team to support operational and production requirements.<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>3.4 Other<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Driver\u2019s License<\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>2.&nbsp;&nbsp;&nbsp;COMPANY GLOBAL REQUIREMENTS<\/strong><\/p>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>4.1 Leadership<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Lead by example, comply with all legal, professional and company requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide guidance to colleagues and through them the business line to maintain engagement in the company\u2019s vision and strategy, build a capable workforce and provide a work environment in which people can perform.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide leadership through promoting and creating buy in for a 10x culture and 5x5 strategy.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure that systems are utilised and maintained as required. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure that effective communication methods are adopted throughout the team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure that HR policies and procedures are followed at all times.<\/li>\n<\/ul>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>4.2 Team focus<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in formal and informal team communication activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in the development and achievement of team goals and workload requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Contribute to the development of new and innovative processes and practices.<\/li>\n<\/ul>\n<p style=\"font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>4.3 Other<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Other appropriate duties as requested by your Employer.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">You must have the right to live and work in this location to apply for this job. <\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Actively participate in the management and compliance of company Country and Global safety policies, procedures and requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comply with all company policies and procedures, including: HR, IT, quality and operations.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3245e4733498-sample-preparer","%breezy_id%":"3245e4733498","%breezy_friendly_id%":"3245e4733498-sample-preparer","%breezy_created_date%":"2026-07-22T21:03:59.527Z","%breezy_updated_date%":"2026-07-23T14:52:30.066Z","%_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","%rank_math_analytic_object_id%":"655"}},"id":3925,"infowindow_disable":false},{"source":"post","title":"Exploration Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Exploration Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/exploration-manager-2\/\" name=\"Exploration Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in&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\/exploration-manager-2\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in Nevada. This role is responsible for managing near-mine and regional exploration programs, overseeing target generation and project development, and leading a high-performing technical team focused on resource growth and discovery.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Nevada-based candidates are preferred; however, qualified candidates throughout the United States will be considered. Candidates should be comfortable working in remote locations and have demonstrated success operating in remote mining and exploration environments.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assess exploration potential, define targets, and develop and manage exploration programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Lead target generation, assessment, and project pipeline management activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Design, evaluate, plan, and prioritize exploration targets at various stages of advancement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Contribute to drill planning for resource discovery, resource growth, and program optimization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate and sequence exploration activities including geological, geochemical, geophysical, and drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure effective utilization of exploration data to support geological interpretation and decision-making.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Implement and oversee QA\/QC programs and procedures across all exploration activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Review QA\/QC data and ensure any issues are identified and addressed promptly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Mentor, develop, and strengthen exploration team capabilities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform and support geological and structural modeling as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">15+ years of exploration experience with Carlin-type, epithermal gold-silver, and similar deposit styles.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Minimum 5 years of leadership experience in exploration management within the mining industry.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with both near-mine and regional exploration programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience advancing both surface and underground projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of QA\/QC principles, implementation, and data evaluation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proficiency with exploration and mining software applications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">GIS and 3D modeling experience preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Excellent leadership, communication, organizational, and team-building skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to manage multiple priorities and meet project deadlines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Bachelor's degree or higher in Geosciences or a related field; field camp experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrated ability and willingness to work in remote mining and exploration environments.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Safety, Environmental, and Compliance<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrate an uncompromising commitment to safety and environmental stewardship.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Adhere to all company safety policies, procedures, and regulatory requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify, report, and correct unsafe conditions and behaviors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Promote a culture of safe and responsible work practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Nevada Preferred (Remote Site-Based Role)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Open to candidates located anywhere in the United States who are willing to relocate and work in a remote mining environment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Work Authorization Requirement<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must be legally authorized to work in the United States at the time of hire and throughout employment. Visa sponsorship is not available for this position.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Exploration Manager","post_link":"https:\/\/turnerstaffing.com\/position\/exploration-manager-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in Nevada. This role is responsible for managing near-mine and regional exploration programs, overseeing target generation and project development, and leading a high-performing technical team focused on resource growth and discovery.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Nevada-based candidates are preferred; however, qualified candidates throughout the United States will be considered. Candidates should be comfortable working in remote locations and have demonstrated success operating in remote mining and exploration environments.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assess exploration potential, define targets, and develop and manage exploration programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Lead target generation, assessment, and project pipeline management activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Design, evaluate, plan, and prioritize exploration targets at various stages of advancement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Contribute to drill planning for resource discovery, resource growth, and program optimization.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate and sequence exploration activities including geological, geochemical, geophysical, and drilling programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure effective utilization of exploration data to support geological interpretation and decision-making.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Implement and oversee QA\/QC programs and procedures across all exploration activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Review QA\/QC data and ensure any issues are identified and addressed promptly.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Mentor, develop, and strengthen exploration team capabilities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform and support geological and structural modeling as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">15+ years of exploration experience with Carlin-type, epithermal gold-silver, and similar deposit styles.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Minimum 5 years of leadership experience in exploration management within the mining industry.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with both near-mine and regional exploration programs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience advancing both surface and underground projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of QA\/QC principles, implementation, and data evaluation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proficiency with exploration and mining software applications.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">GIS and 3D modeling experience preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Excellent leadership, communication, organizational, and team-building skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to manage multiple priorities and meet project deadlines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Bachelor's degree or higher in Geosciences or a related field; field camp experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrated ability and willingness to work in remote mining and exploration environments.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Safety, Environmental, and Compliance<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrate an uncompromising commitment to safety and environmental stewardship.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Adhere to all company safety policies, procedures, and regulatory requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify, report, and correct unsafe conditions and behaviors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Promote a culture of safe and responsible work practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Nevada Preferred (Remote Site-Based Role)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Open to candidates located anywhere in the United States who are willing to relocate and work in a remote mining environment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Work Authorization Requirement<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must be legally authorized to work in the United States at the time of hire and throughout employment. Visa sponsorship is not available for this position.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/98dc818ba296-exploration-manager","%breezy_id%":"98dc818ba296","%breezy_friendly_id%":"98dc818ba296-exploration-manager","%breezy_created_date%":"2026-07-23T20:59:52.853Z","%breezy_updated_date%":"2026-07-23T20:59:55.056Z","%_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%":"656"}},"id":3926,"infowindow_disable":false},{"source":"post","title":"Ready Mix Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Ready Mix Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You&#8217;ll Be Doing Safely operate a ready-mix truck to deliver concrete to customer job sites Perform pre-trip and post-trip&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/ready-mix-driver\/\" name=\"Ready Mix Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You&#8217;ll Be Doing Safely operate a ready-mix truck to deliver concrete to customer job sites Perform pre-trip and post-trip&hellip;","address":"Central Square, NY, USA","location":{"lat":"43.2867356","city":"Central Square","state":"NY","country":"United States","lng":"-76.1460357","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/ready-mix-driver\/","zoom":19,"extra_fields":{"post_excerpt":"What You&#8217;ll Be Doing Safely operate a ready-mix truck to deliver concrete to customer job sites Perform pre-trip and post-trip&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You'll Be Doing<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safely operate a ready-mix truck to deliver concrete to customer job sites<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform pre-trip and post-trip inspections to ensure vehicle safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate effectively with dispatch and customers for timely deliveries<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain accurate delivery tickets and related documentation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Adhere to all safety policies and procedures at all times<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What Are We Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid CDL Class A or B license with clean driving record<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to operate heavy equipment safely and efficiently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong focus on safety and customer service<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Capability to work independently and manage time effectively<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical ability to perform job duties, including lifting and climbing<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Conditions of Employment<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must comply with all company and regulatory safety requirements<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Work Environment<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We Offer<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">$22.00 - $32.00 per hour<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Highly competitive benefits programs, including:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Medical, Dental, and Vision along with Prescription Drug Benefits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Health Savings Account (HSA), Health Reimbursement Account (HRA) and Flexible Spending Account (FSA)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Paid Bonding Leave, Paid Vacation, 56 hours of Paid Sick Leave and 10 Paid Holidays<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Ready Mix Driver","post_link":"https:\/\/turnerstaffing.com\/position\/ready-mix-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Central Square","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Central Square, NY","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You'll Be Doing<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safely operate a ready-mix truck to deliver concrete to customer job sites<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform pre-trip and post-trip inspections to ensure vehicle safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate effectively with dispatch and customers for timely deliveries<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain accurate delivery tickets and related documentation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Adhere to all safety policies and procedures at all times<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What Are We Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid CDL Class A or B license with clean driving record<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to operate heavy equipment safely and efficiently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong focus on safety and customer service<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Capability to work independently and manage time effectively<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical ability to perform job duties, including lifting and climbing<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Conditions of Employment<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must comply with all company and regulatory safety requirements<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Work Environment<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We Offer<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">$22.00 - $32.00 per hour<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Highly competitive benefits programs, including:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Medical, Dental, and Vision along with Prescription Drug Benefits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Health Savings Account (HSA), Health Reimbursement Account (HRA) and Flexible Spending Account (FSA)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Paid Bonding Leave, Paid Vacation, 56 hours of Paid Sick Leave and 10 Paid Holidays<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/bd5a3c10fcd4-ready-mix-driver","%breezy_id%":"bd5a3c10fcd4","%breezy_friendly_id%":"bd5a3c10fcd4-ready-mix-driver","%breezy_created_date%":"2026-07-23T22:04:04.137Z","%breezy_updated_date%":"2026-07-23T22:04:06.380Z","%_wpgmp_location_city%":"Central Square","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Central Square, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.2867356","%_wpgmp_metabox_longitude%":"-76.1460357","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"657"}},"id":3927,"infowindow_disable":false},{"source":"post","title":"Sample Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Sample Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking Technician Samplers for an approximately 12-month contract assignment supporting mining operations. This position plays a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/sample-technician\/\" name=\"Sample Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking Technician Samplers for an approximately 12-month contract assignment supporting mining operations. This position plays a&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\/sample-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking Technician Samplers for an approximately 12-month contract assignment supporting mining operations. This position plays a&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is seeking <strong>Technician Samplers<\/strong> for an approximately <strong>12-month contract assignment<\/strong> supporting mining operations. This position plays a critical role in ensuring drill samples are accurately collected, labeled, and delivered for processing. The ideal candidate is safety-focused, dependable, and comfortable working in demanding outdoor mining environments.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Tag sample bags with the correct identification.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Verify that the correct bag IDs are used for the appropriate drill hole and footage.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Collect drill samples every 10 feet from the drill sampler.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure sample bags are properly tagged and securely sealed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Deliver completed samples to the core shed at the end of each shift.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain a safe work environment by following all site safety procedures and company policies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform duties accurately while working in a fast-paced mining environment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Minimum of <strong>1 year of experience<\/strong> in an open-pit or underground mining environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver's license held for <strong>at least one year<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong commitment to workplace safety.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to lift and carry sample bags weighing up to <strong>50 pounds<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in challenging environmental conditions, including heat, cold, dust, and uneven terrain.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reliable attendance and willingness to work rotating day and night shifts.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Open-pit driving experience.<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Schedule<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Schedule:<\/strong> 5-4 rotating schedule consisting of both day and night shifts.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>Assignment Length:<\/strong> Approximately 12 months.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Additional Requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must be authorized to work in the United States <strong>without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">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, protected veteran status, or any other characteristic protected by applicable law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Sample Technician","post_link":"https:\/\/turnerstaffing.com\/position\/sample-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%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=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is seeking <strong>Technician Samplers<\/strong> for an approximately <strong>12-month contract assignment<\/strong> supporting mining operations. This position plays a critical role in ensuring drill samples are accurately collected, labeled, and delivered for processing. The ideal candidate is safety-focused, dependable, and comfortable working in demanding outdoor mining environments.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Tag sample bags with the correct identification.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Verify that the correct bag IDs are used for the appropriate drill hole and footage.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Collect drill samples every 10 feet from the drill sampler.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure sample bags are properly tagged and securely sealed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Deliver completed samples to the core shed at the end of each shift.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain a safe work environment by following all site safety procedures and company policies.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform duties accurately while working in a fast-paced mining environment.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Minimum of <strong>1 year of experience<\/strong> in an open-pit or underground mining environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver's license held for <strong>at least one year<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong commitment to workplace safety.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to lift and carry sample bags weighing up to <strong>50 pounds<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in challenging environmental conditions, including heat, cold, dust, and uneven terrain.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reliable attendance and willingness to work rotating day and night shifts.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Open-pit driving experience.<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Schedule<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Schedule:<\/strong> 5-4 rotating schedule consisting of both day and night shifts.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>Assignment Length:<\/strong> Approximately 12 months.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Additional Requirements<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must be authorized to work in the United States <strong>without current or future visa sponsorship<\/strong>.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">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, protected veteran status, or any other characteristic protected by applicable law.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3babe029cbd1-sample-technician","%breezy_id%":"3babe029cbd1","%breezy_friendly_id%":"3babe029cbd1-sample-technician","%breezy_created_date%":"2026-07-24T22:07:32.304Z","%breezy_updated_date%":"2026-07-24T22:07:34.375Z","%_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%":"658"}},"id":3928,"infowindow_disable":false},{"source":"post","title":"Senior Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview Our client is seeking an experienced Senior Geologist to support gold mining operations in the Elko, Nevada area.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-geologist\/\" name=\"Senior Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview Our client is seeking an experienced Senior Geologist to support gold mining operations in the Elko, Nevada area.&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\/senior-geologist\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview Our client is seeking an experienced Senior Geologist to support gold mining operations in the Elko, Nevada area.&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Position Overview<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Our client is seeking an experienced <strong>Senior Geologist<\/strong> to support gold mining operations in the Elko, Nevada area. The Senior Geologist will play a key role in geological interpretation, ore control, resource development, exploration, and production support across underground and\/or surface mining operations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The ideal candidate will have strong experience in gold exploration and mining, excellent geological modeling and data interpretation skills, and the ability to work collaboratively with mining, engineering, and operations teams. This position requires a hands-on geologist who can work effectively in the field while also managing and interpreting geological data to support safe, efficient, and economically successful mine operations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide senior-level geological support to active gold mining operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct and oversee geological mapping, sampling, logging, and interpretation activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support ore control programs, including grade control drilling, sampling, geological interpretation, and reconciliation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Interpret drill data, assay results, structural geology, lithology, alteration, and mineralization to support mine planning and production decisions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Develop and maintain geological models and databases using industry-standard geological software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with resource estimation, reserve development, and geological modeling activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work closely with mine engineering and operations teams to ensure geological interpretations are incorporated into mine plans and production schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Monitor and interpret geological conditions encountered during mining and provide recommendations to support operational decisions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Review and validate geological and assay data to ensure accuracy, quality, and integrity.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate with drilling and sampling teams to ensure appropriate data collection and quality-control procedures are followed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in underground and surface mapping and geological inspections as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify and communicate geological risks and opportunities that may impact mine planning, production, or resource development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Contribute to short- and long-term mine planning through geological interpretation and technical input.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prepare geological reports, maps, cross-sections, technical summaries, and presentations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support resource and reserve reporting in accordance with applicable industry standards and company procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Mentor and provide technical guidance to junior and intermediate-level geologists and geological technicians.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain a strong focus on safety, environmental responsibility, and compliance with mine site policies and regulatory requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform other geological and operational duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Bachelor's degree in Geology, Geological Engineering, or a related field.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\n<strong>7+ years of progressive geological experience<\/strong>, preferably within gold mining or mineral exploration.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience working in active mining operations, preferably with exposure to both underground and surface mining environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of economic geology, structural geology, mineralization, and ore deposit interpretation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with ore control, grade control, geological mapping, core logging, and sampling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience interpreting drill results, assay data, and geological datasets.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proficiency with geological modeling, database, and mine planning software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong technical writing, reporting, and communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work effectively with mine operations, engineering, environmental, and exploration teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in a field-based mining environment and conduct work underground and\/or in active surface mine areas.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver's license and ability to meet mine site access requirements.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience working in the <strong>Carlin Trend or Great Basin<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous experience with Nevada gold deposits and operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with underground mining methods and production geology.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with Leapfrog, Vulcan, MineSight, Datamine, Surpac, or similar geological and mine modeling software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with QA\/QC programs and geological database management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience supporting resource estimation and mineral resource reporting.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Professional registration or eligibility for professional registration is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA Part 46 or Part 48 training is preferred, depending on site requirements.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Skills and Attributes<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong analytical and problem-solving abilities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Excellent attention to detail and data accuracy.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to make sound geological judgments in a fast-paced operational environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong communication and interpersonal skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to prioritize multiple projects and meet deadlines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comfortable working independently while contributing effectively to a multidisciplinary team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety-conscious approach to field and mine-site activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong leadership and mentoring capabilities.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Environment<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">This position will be based at a gold mining operation in the <strong>Elko, Nevada area<\/strong>. The role may require a combination of office, field, surface mine, and underground work depending on operational requirements. Candidates must be comfortable working in active mine environments and following all site-specific health, safety, and environmental procedures.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Senior Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/senior-geologist\/","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=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Position Overview<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Our client is seeking an experienced <strong>Senior Geologist<\/strong> to support gold mining operations in the Elko, Nevada area. The Senior Geologist will play a key role in geological interpretation, ore control, resource development, exploration, and production support across underground and\/or surface mining operations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The ideal candidate will have strong experience in gold exploration and mining, excellent geological modeling and data interpretation skills, and the ability to work collaboratively with mining, engineering, and operations teams. This position requires a hands-on geologist who can work effectively in the field while also managing and interpreting geological data to support safe, efficient, and economically successful mine operations.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide senior-level geological support to active gold mining operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct and oversee geological mapping, sampling, logging, and interpretation activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support ore control programs, including grade control drilling, sampling, geological interpretation, and reconciliation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Interpret drill data, assay results, structural geology, lithology, alteration, and mineralization to support mine planning and production decisions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Develop and maintain geological models and databases using industry-standard geological software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with resource estimation, reserve development, and geological modeling activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work closely with mine engineering and operations teams to ensure geological interpretations are incorporated into mine plans and production schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Monitor and interpret geological conditions encountered during mining and provide recommendations to support operational decisions.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Review and validate geological and assay data to ensure accuracy, quality, and integrity.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate with drilling and sampling teams to ensure appropriate data collection and quality-control procedures are followed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in underground and surface mapping and geological inspections as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify and communicate geological risks and opportunities that may impact mine planning, production, or resource development.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Contribute to short- and long-term mine planning through geological interpretation and technical input.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prepare geological reports, maps, cross-sections, technical summaries, and presentations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support resource and reserve reporting in accordance with applicable industry standards and company procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Mentor and provide technical guidance to junior and intermediate-level geologists and geological technicians.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain a strong focus on safety, environmental responsibility, and compliance with mine site policies and regulatory requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform other geological and operational duties as assigned.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Bachelor's degree in Geology, Geological Engineering, or a related field.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\n<strong>7+ years of progressive geological experience<\/strong>, preferably within gold mining or mineral exploration.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience working in active mining operations, preferably with exposure to both underground and surface mining environments.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of economic geology, structural geology, mineralization, and ore deposit interpretation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with ore control, grade control, geological mapping, core logging, and sampling.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience interpreting drill results, assay data, and geological datasets.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proficiency with geological modeling, database, and mine planning software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong technical writing, reporting, and communication skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work effectively with mine operations, engineering, environmental, and exploration teams.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in a field-based mining environment and conduct work underground and\/or in active surface mine areas.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver's license and ability to meet mine site access requirements.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience working in the <strong>Carlin Trend or Great Basin<\/strong>.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous experience with Nevada gold deposits and operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with underground mining methods and production geology.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with Leapfrog, Vulcan, MineSight, Datamine, Surpac, or similar geological and mine modeling software.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with QA\/QC programs and geological database management.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience supporting resource estimation and mineral resource reporting.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Professional registration or eligibility for professional registration is a plus.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA Part 46 or Part 48 training is preferred, depending on site requirements.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Skills and Attributes<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong analytical and problem-solving abilities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Excellent attention to detail and data accuracy.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to make sound geological judgments in a fast-paced operational environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong communication and interpersonal skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to prioritize multiple projects and meet deadlines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comfortable working independently while contributing effectively to a multidisciplinary team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety-conscious approach to field and mine-site activities.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong leadership and mentoring capabilities.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Environment<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">This position will be based at a gold mining operation in the <strong>Elko, Nevada area<\/strong>. The role may require a combination of office, field, surface mine, and underground work depending on operational requirements. Candidates must be comfortable working in active mine environments and following all site-specific health, safety, and environmental procedures.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/8929902ecde6-senior-geologist","%breezy_id%":"8929902ecde6","%breezy_friendly_id%":"8929902ecde6-senior-geologist","%breezy_created_date%":"2026-07-27T19:34:20.604Z","%breezy_updated_date%":"2026-07-27T19:34:28.249Z","%_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%":"659"}},"id":3929,"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 style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Job Title: Heavy Equipment Operator<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Company: Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Location: Kershaw, South Carolina, USA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Position Type: Full-Time<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">About Us: Turner 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Job Overview: 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsibilities:<\/p><ol style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equipment Operation:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li>\n<\/ul><ol style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety Compliance:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct routine equipment inspections and report any issues promptly.<\/li>\n<\/ul><ol style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Efficiency and Productivity:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Meet project deadlines and production targets while maintaining high-quality standards.<\/li>\n<\/ul><ol style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communication:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Report any operational challenges or concerns in a timely manner.<\/li>\n<\/ul><ol style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintenance Support:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Requirements:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Familiarity with safety regulations and commitment to safe work practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to operate various heavy equipment efficiently and skillfully.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong communication and teamwork skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Education and Certifications:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High school diploma or equivalent.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Relevant certifications for heavy equipment operation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA experience preferred.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Benefits:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Competitive salary<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Health, dental, and vision insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Retirement savings plan<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","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%":"","%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%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Job Title: Heavy Equipment Operator<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Company: Turner Staffing Group<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Location: Kershaw, South Carolina, USA<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Position Type: Full-Time<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">About Us: Turner 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Job Overview: 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities:<\/p><ol style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equipment Operation:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li>\n<\/ul><ol style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety Compliance:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct routine equipment inspections and report any issues promptly.<\/li>\n<\/ul><ol style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Efficiency and Productivity:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Meet project deadlines and production targets while maintaining high-quality standards.<\/li>\n<\/ul><ol style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communication:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Report any operational challenges or concerns in a timely manner.<\/li>\n<\/ul><ol style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintenance Support:<\/li><\/ol><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Requirements:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Familiarity with safety regulations and commitment to safe work practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to operate various heavy equipment efficiently and skillfully.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong communication and teamwork skills.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Education and Certifications:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High school diploma or equivalent.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Relevant certifications for heavy equipment operation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA experience preferred.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Benefits:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Competitive salary<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Health, dental, and vision insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Retirement savings plan<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/7fa9c5b18f2b-heavy-equipment-operator","%breezy_id%":"7fa9c5b18f2b","%breezy_friendly_id%":"7fa9c5b18f2b-heavy-equipment-operator","%breezy_created_date%":"2026-07-15T21:15:48.439Z","%breezy_updated_date%":"2026-07-15T21:15:56.692Z","%_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","%rank_math_analytic_object_id%":"648"}},"id":3918,"infowindow_disable":false},{"source":"post","title":"Infrastructure Rehabilitation Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Infrastructure Rehabilitation Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Infrastructure Rehabilitation Supervisor A growing infrastructure contractor is seeking an experienced Infrastructure Rehabilitation Supervisor to oversee wastewater, stormwater, and potable&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/infrastructure-rehabilitation-supervisor\/\" name=\"Infrastructure Rehabilitation Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Infrastructure Rehabilitation Supervisor A growing infrastructure contractor is seeking an experienced Infrastructure Rehabilitation Supervisor to oversee wastewater, stormwater, and potable&hellip;","address":"Lancaster, PA, USA","location":{"lat":"40.0403279","city":"Lancaster","state":"PA","country":"United States","lng":"-76.3041833","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/infrastructure-rehabilitation-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Infrastructure Rehabilitation Supervisor A growing infrastructure contractor is seeking an experienced Infrastructure Rehabilitation Supervisor to oversee wastewater, stormwater, and potable&hellip;","post_content":"<p>Infrastructure Rehabilitation Supervisor<\/p>\n<p>A growing infrastructure contractor is seeking an experienced <strong>Infrastructure Rehabilitation Supervisor<\/strong> to oversee wastewater, stormwater, and potable water rehabilitation projects throughout the Mid-Atlantic region. This is a year-round position offering competitive compensation, paid time off, and a comprehensive benefits package.<\/p>\n<p>Key Responsibilities<\/p>\n<ul><li>Supervise field crews performing underground infrastructure rehabilitation work.<\/li><li>Oversee projects involving cured-in-place pipe lining, structure rehabilitation, CCTV inspection, pipeline cleaning, and related services.<\/li><li>Coordinate daily project activities with project managers, engineers, owners, and subcontractors.<\/li><li>Assign work, monitor crew performance, and assist with employee training.<\/li><li>Track daily production, job progress, labor, equipment usage, and project documentation.<\/li><li>Enforce company safety policies and applicable jobsite regulations.<\/li><li>Oversee the operation of curing units, vacuum and blower trucks, camera trucks, spray equipment, preparation trucks, bypass pumping systems, forklifts, and other specialized equipment.<\/li><li>Identify field issues and communicate changes, delays, or resource needs to project leadership.<\/li><li>Maintain quality standards and ensure work is completed according to project specifications.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Approximately 5\u201310 years of experience in underground utilities, pipeline rehabilitation, wastewater systems, or a related construction field.<\/li><li>Previous experience supervising field employees and coordinating active construction projects.<\/li><li>Familiarity with CIPP lining, pipeline cleaning, CCTV inspection, bypass pumping, or structure rehabilitation is strongly preferred.<\/li><li>Valid driver\u2019s license with an acceptable driving record.<\/li><li>Strong communication, organization, and crew-management skills.<\/li><li>Dependable, safety-focused, and capable of working efficiently in a field environment.<\/li><li>Ability to travel to project locations throughout the region as needed.<\/li><li>Must successfully complete a pre-employment drug screening.<\/li><\/ul>\n<p>Compensation and Benefits<\/p>\n<ul><li>Competitive wages based on experience<\/li><li>Year-round employment<\/li><li>Paid vacation<\/li><li>Comprehensive benefits package<\/li><li>Opportunities for advancement within the organization<\/li><\/ul>\n<p><br>\n\n<\/p>","post_title":"Infrastructure Rehabilitation Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/infrastructure-rehabilitation-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Lancaster","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Lancaster, PA","%education%":"","%department%":"TSG","%description%":"<p>Infrastructure Rehabilitation Supervisor<\/p>\n<p>A growing infrastructure contractor is seeking an experienced <strong>Infrastructure Rehabilitation Supervisor<\/strong> to oversee wastewater, stormwater, and potable water rehabilitation projects throughout the Mid-Atlantic region. This is a year-round position offering competitive compensation, paid time off, and a comprehensive benefits package.<\/p>\n<p>Key Responsibilities<\/p>\n<ul><li>Supervise field crews performing underground infrastructure rehabilitation work.<\/li><li>Oversee projects involving cured-in-place pipe lining, structure rehabilitation, CCTV inspection, pipeline cleaning, and related services.<\/li><li>Coordinate daily project activities with project managers, engineers, owners, and subcontractors.<\/li><li>Assign work, monitor crew performance, and assist with employee training.<\/li><li>Track daily production, job progress, labor, equipment usage, and project documentation.<\/li><li>Enforce company safety policies and applicable jobsite regulations.<\/li><li>Oversee the operation of curing units, vacuum and blower trucks, camera trucks, spray equipment, preparation trucks, bypass pumping systems, forklifts, and other specialized equipment.<\/li><li>Identify field issues and communicate changes, delays, or resource needs to project leadership.<\/li><li>Maintain quality standards and ensure work is completed according to project specifications.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Approximately 5\u201310 years of experience in underground utilities, pipeline rehabilitation, wastewater systems, or a related construction field.<\/li><li>Previous experience supervising field employees and coordinating active construction projects.<\/li><li>Familiarity with CIPP lining, pipeline cleaning, CCTV inspection, bypass pumping, or structure rehabilitation is strongly preferred.<\/li><li>Valid driver\u2019s license with an acceptable driving record.<\/li><li>Strong communication, organization, and crew-management skills.<\/li><li>Dependable, safety-focused, and capable of working efficiently in a field environment.<\/li><li>Ability to travel to project locations throughout the region as needed.<\/li><li>Must successfully complete a pre-employment drug screening.<\/li><\/ul>\n<p>Compensation and Benefits<\/p>\n<ul><li>Competitive wages based on experience<\/li><li>Year-round employment<\/li><li>Paid vacation<\/li><li>Comprehensive benefits package<\/li><li>Opportunities for advancement within the organization<\/li><\/ul>\n<p><br>\n\n<\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a858c0b66713-infrastructure-rehabilitation-supervisor","%breezy_id%":"a858c0b66713","%breezy_friendly_id%":"a858c0b66713-infrastructure-rehabilitation-supervisor","%breezy_created_date%":"2026-07-17T17:26:30.599Z","%breezy_updated_date%":"2026-07-17T17:27:16.768Z","%_wpgmp_location_city%":"Lancaster","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lancaster, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.0403279","%_wpgmp_metabox_longitude%":"-76.3041833","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"649"}},"id":3919,"infowindow_disable":false},{"source":"post","title":"Infrastructure Rehabilitation Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Infrastructure Rehabilitation Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Infrastructure Rehabilitation Supervisor A growing infrastructure contractor is seeking an experienced Infrastructure Rehabilitation Supervisor to oversee wastewater, stormwater, and potable&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/infrastructure-rehabilitation-supervisor-2\/\" name=\"Infrastructure Rehabilitation Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Infrastructure Rehabilitation Supervisor A growing infrastructure contractor is seeking an experienced Infrastructure Rehabilitation Supervisor to oversee wastewater, stormwater, and potable&hellip;","address":"Lancaster, PA, USA","location":{"lat":"40.0403279","city":"Lancaster","state":"PA","country":"United States","lng":"-76.3041833","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/infrastructure-rehabilitation-supervisor-2\/","zoom":19,"extra_fields":{"post_excerpt":"Infrastructure Rehabilitation Supervisor A growing infrastructure contractor is seeking an experienced Infrastructure Rehabilitation Supervisor to oversee wastewater, stormwater, and potable&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Infrastructure Rehabilitation Supervisor<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">A growing infrastructure contractor is seeking an experienced <strong>Infrastructure Rehabilitation Supervisor<\/strong> to oversee wastewater, stormwater, and potable water rehabilitation projects throughout the Mid-Atlantic region. This is a year-round position offering competitive compensation, paid time off, and a comprehensive benefits package.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Supervise field crews performing underground infrastructure rehabilitation work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Oversee projects involving cured-in-place pipe lining, structure rehabilitation, CCTV inspection, pipeline cleaning, and related services.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate daily project activities with project managers, engineers, owners, and subcontractors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assign work, monitor crew performance, and assist with employee training.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Track daily production, job progress, labor, equipment usage, and project documentation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Enforce company safety policies and applicable jobsite regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Oversee the operation of curing units, vacuum and blower trucks, camera trucks, spray equipment, preparation trucks, bypass pumping systems, forklifts, and other specialized equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify field issues and communicate changes, delays, or resource needs to project leadership.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain quality standards and ensure work is completed according to project specifications.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Approximately 5\u201310 years of experience in underground utilities, pipeline rehabilitation, wastewater systems, or a related construction field.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous experience supervising field employees and coordinating active construction projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Familiarity with CIPP lining, pipeline cleaning, CCTV inspection, bypass pumping, or structure rehabilitation is strongly preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver\u2019s license with an acceptable driving record.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong communication, organization, and crew-management skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Dependable, safety-focused, and capable of working efficiently in a field environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to travel to project locations throughout the region as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must successfully complete a pre-employment drug screening.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Compensation and Benefits<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Competitive wages based on experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Year-round employment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Paid vacation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comprehensive benefits package<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Opportunities for advancement within the organization<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Infrastructure Rehabilitation Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/infrastructure-rehabilitation-supervisor-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Lancaster","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Lancaster, PA","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Infrastructure Rehabilitation Supervisor<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">A growing infrastructure contractor is seeking an experienced <strong>Infrastructure Rehabilitation Supervisor<\/strong> to oversee wastewater, stormwater, and potable water rehabilitation projects throughout the Mid-Atlantic region. This is a year-round position offering competitive compensation, paid time off, and a comprehensive benefits package.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Supervise field crews performing underground infrastructure rehabilitation work.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Oversee projects involving cured-in-place pipe lining, structure rehabilitation, CCTV inspection, pipeline cleaning, and related services.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate daily project activities with project managers, engineers, owners, and subcontractors.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assign work, monitor crew performance, and assist with employee training.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Track daily production, job progress, labor, equipment usage, and project documentation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Enforce company safety policies and applicable jobsite regulations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Oversee the operation of curing units, vacuum and blower trucks, camera trucks, spray equipment, preparation trucks, bypass pumping systems, forklifts, and other specialized equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify field issues and communicate changes, delays, or resource needs to project leadership.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain quality standards and ensure work is completed according to project specifications.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Approximately 5\u201310 years of experience in underground utilities, pipeline rehabilitation, wastewater systems, or a related construction field.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous experience supervising field employees and coordinating active construction projects.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Familiarity with CIPP lining, pipeline cleaning, CCTV inspection, bypass pumping, or structure rehabilitation is strongly preferred.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver\u2019s license with an acceptable driving record.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong communication, organization, and crew-management skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Dependable, safety-focused, and capable of working efficiently in a field environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to travel to project locations throughout the region as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must successfully complete a pre-employment drug screening.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Compensation and Benefits<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Competitive wages based on experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Year-round employment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Paid vacation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comprehensive benefits package<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Opportunities for advancement within the organization<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/842c52a24bc6-infrastructure-rehabilitation-supervisor","%breezy_id%":"842c52a24bc6","%breezy_friendly_id%":"842c52a24bc6-infrastructure-rehabilitation-supervisor","%breezy_created_date%":"2026-07-17T17:36:34.620Z","%breezy_updated_date%":"2026-09-08T22:26:11.483Z","%_wpgmp_location_city%":"Lancaster","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lancaster, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.0403279","%_wpgmp_metabox_longitude%":"-76.3041833","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"650"}},"id":3920,"infowindow_disable":false},{"source":"post","title":"Heavy Diesel Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Diesel Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Details Where You Will Work&nbsp;&nbsp; Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-diesel-mechanic\/\" name=\"Heavy Diesel Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Details Where You Will Work&nbsp;&nbsp; Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations&hellip;","address":"Morenci, AZ, USA","location":{"lat":"33.0508859","city":"Morenci","state":"AZ","country":"United States","lng":"-109.3280282","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-diesel-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Job Details Where You Will Work&nbsp;&nbsp; Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Job Details<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Where You Will Work<\/strong>&nbsp;&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations (an open-pit copper mining complex) has been in continuous operation since 1939. The operation consists of two concentrators, crushed-ore leach pad and stacking system, a low-grade run-of-mine (ROM) leaching system; four SX plants; and three EW tank houses that produce copper cathode.&nbsp;&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Morenci is a unique company town where our employees and their families can reconnect with nature through hiking, fishing, camping, hunting and numerous parks. The company offers several amenities, including company housing OR employees who are required to work on-site are eligible for a $750 monthly housing allowance, provided they meet program guidelines, a newly constructed daycare and community center, library, health-care facilities, state-of-the-art fitness centers, a movie theater and a skate park. Our dedicated Parks and Recreation Division plans activities for people of all ages, making sure there\u2019s something for everyone to enjoy. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Will Do<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform diagnostic, maintenance and repair of heavy equipment such as, but not limited to: Haul Trucks, Water Trucks, Rubber Tire and Track Dozers, Front-end Loaders, and Motor Graders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform the removal, repair and installation of transmissions, engines, breaks, differentials, pumps, motors, torque convertors, final drives and other heavy equipment systems or components.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform mechanical and lubrication preventative maintenance on machine systems such as: hydraulic, power train and engines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prioritize and make decisions regarding equipment repair as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsible for maintaining work orders and performing work area inspections.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate mobile equipment such as: Overhead cranes, forklifts, and boom trucks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform welding such as: Carbon arc, Plasma, Mig, Tig, and Stick.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform as a Fill-in Supervisor as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Train and mentor other employees.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform other duties as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Bring To Freeport<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Two (2) years\u2019 experience in mechanical\/maintenance crafts (including welder, boilermaker, machinist or facility maintenance\/construction) or a combination of education and experience in industrial mechanical repair and maintenance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have completed academic and practical competencies required (this includes Line of Progression requirements for internal employees where LOP Exists) and have experience demonstrating the required mechanical aptitude.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">HEM Diagnostic Mechanic I: Practical Skills Assessments defined in LOP.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to understand and apply verbal and written work and safety-related instructions and procedures in English<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to communicate in English with respect to job assignments, job procedures, and applicable safety standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to prioritize repairs and possess excellent decision-making skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to troubleshoot machine systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work and effectively communicate with others<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to read and use blueprints<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Preferred Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High School Diploma or GED<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We Offer You&nbsp;<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The estimated pay range for this role is currently\u202f<strong>$28.00 - $38.00\/hour.<\/strong> This range reflects base salary only and does not include bonus payments, benefits or retirement contributions. Actual base pay is determined by experience, qualifications, skills and other job-related factors. This role is eligible for additional discretionary and incentive payment considerations based on company and individual performance. <\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employees who are required to work on-site are eligible for a $750 monthly housing allowance, provided they meet program guidelines<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Affordable medical, dental and vision benefits&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Company-paid life and disability insurance&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">401(k) plan with employer contribution\/match&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Paid time off, paid sick time, holiday pay, parental leave&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Tuition assistance&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employee Assistance Program&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Discounted insurance plans for pet, auto, home and vehicle&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Internal progression opportunities&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We Require <\/strong>&nbsp;<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates may be required to pass a medical exam.&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must pass all required training and\/or testing.&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employees may be required to work a non-standard schedule, which may include shift work (other than day shift) at a 24\/7, 365-day operation.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Heavy Diesel Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-diesel-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Morenci","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Morenci, AZ","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Job Details<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Where You Will Work<\/strong>&nbsp;&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations (an open-pit copper mining complex) has been in continuous operation since 1939. The operation consists of two concentrators, crushed-ore leach pad and stacking system, a low-grade run-of-mine (ROM) leaching system; four SX plants; and three EW tank houses that produce copper cathode.&nbsp;&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Morenci is a unique company town where our employees and their families can reconnect with nature through hiking, fishing, camping, hunting and numerous parks. The company offers several amenities, including company housing OR employees who are required to work on-site are eligible for a $750 monthly housing allowance, provided they meet program guidelines, a newly constructed daycare and community center, library, health-care facilities, state-of-the-art fitness centers, a movie theater and a skate park. Our dedicated Parks and Recreation Division plans activities for people of all ages, making sure there\u2019s something for everyone to enjoy. <\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Will Do<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform diagnostic, maintenance and repair of heavy equipment such as, but not limited to: Haul Trucks, Water Trucks, Rubber Tire and Track Dozers, Front-end Loaders, and Motor Graders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform the removal, repair and installation of transmissions, engines, breaks, differentials, pumps, motors, torque convertors, final drives and other heavy equipment systems or components.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform mechanical and lubrication preventative maintenance on machine systems such as: hydraulic, power train and engines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prioritize and make decisions regarding equipment repair as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsible for maintaining work orders and performing work area inspections.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate mobile equipment such as: Overhead cranes, forklifts, and boom trucks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform welding such as: Carbon arc, Plasma, Mig, Tig, and Stick.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform as a Fill-in Supervisor as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Train and mentor other employees.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform other duties as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Bring To Freeport<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Two (2) years\u2019 experience in mechanical\/maintenance crafts (including welder, boilermaker, machinist or facility maintenance\/construction) or a combination of education and experience in industrial mechanical repair and maintenance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have completed academic and practical competencies required (this includes Line of Progression requirements for internal employees where LOP Exists) and have experience demonstrating the required mechanical aptitude.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">HEM Diagnostic Mechanic I: Practical Skills Assessments defined in LOP.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to understand and apply verbal and written work and safety-related instructions and procedures in English<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to communicate in English with respect to job assignments, job procedures, and applicable safety standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to prioritize repairs and possess excellent decision-making skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to troubleshoot machine systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work and effectively communicate with others<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to read and use blueprints<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Preferred Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High School Diploma or GED<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We Offer You&nbsp;<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The estimated pay range for this role is currently\u202f<strong>$28.00 - $38.00\/hour.<\/strong> This range reflects base salary only and does not include bonus payments, benefits or retirement contributions. Actual base pay is determined by experience, qualifications, skills and other job-related factors. This role is eligible for additional discretionary and incentive payment considerations based on company and individual performance. <\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employees who are required to work on-site are eligible for a $750 monthly housing allowance, provided they meet program guidelines<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Affordable medical, dental and vision benefits&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Company-paid life and disability insurance&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">401(k) plan with employer contribution\/match&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Paid time off, paid sick time, holiday pay, parental leave&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Tuition assistance&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employee Assistance Program&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Discounted insurance plans for pet, auto, home and vehicle&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Internal progression opportunities&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">&nbsp;<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We Require <\/strong>&nbsp;<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates may be required to pass a medical exam.&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must pass all required training and\/or testing.&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employees may be required to work a non-standard schedule, which may include shift work (other than day shift) at a 24\/7, 365-day operation.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/d63fe82517b9-heavy-diesel-mechanic","%breezy_id%":"d63fe82517b9","%breezy_friendly_id%":"d63fe82517b9-heavy-diesel-mechanic","%breezy_created_date%":"2026-07-20T21:44:22.280Z","%breezy_updated_date%":"2026-07-23T15:06:32.601Z","%_wpgmp_location_city%":"Morenci","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Morenci, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.0508859","%_wpgmp_metabox_longitude%":"-109.3280282","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"652"}},"id":3922,"infowindow_disable":false},{"source":"post","title":"Directional Drilling Locator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Directional Drilling Locator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are seeking an experienced Directional Drill Locator to join a two-person horizontal directional drilling crew. This individual&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/directional-drilling-locator\/\" name=\"Directional Drilling Locator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are seeking an experienced Directional Drill Locator to join a two-person horizontal directional drilling crew. This individual&hellip;","address":"Harmony, MN, USA","location":{"lat":"43.5551811","city":"Harmony","state":"MN","country":"United States","lng":"-92.0052837","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/directional-drilling-locator\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are seeking an experienced Directional Drill Locator to join a two-person horizontal directional drilling crew. This individual&hellip;","post_content":"<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking an experienced Directional Drill Locator to join a two-person horizontal directional drilling crew. This individual will work closely with an experienced drill operator to safely and accurately install underground fiber conduit and larger-diameter pipe.<\/p>\n<p>The ideal candidate can independently locate the drill head, operate supporting equipment, and transport the drill package using a Class A CDL.<\/p>\n<p><\/p>\n<p><strong>Responsibilities<\/strong><\/p>\n<ul><li>Track the drill head and communicate depth, pitch, roll, direction, and steering corrections to the drill operator.<\/li><li>Operate DCI\/DigiTrak and Underground Magnetics locating systems.<\/li><li>Review bore paths, utility markings, entry points, exit points, and required depths.<\/li><li>Maintain safe clearance from existing underground utilities.<\/li><li>Assist with pilot boring, backreaming, conduit installation, and pullback.<\/li><li>Operate a mud vacuum and support potholing, drilling-fluid management, and jobsite cleanup.<\/li><li>Assist with directional drill setup, operation, inspections, and basic maintenance.<\/li><li>Drive a Class A truck and trailer with air brakes to transport an approximately 40,000-pound drill package.<\/li><li>Complete approximately five drill shots per day, depending on project conditions.<\/li><li>Perform general field duties necessary to support the two-person crew.<\/li><\/ul>\n<p><\/p>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Previous HDD drill-locating experience.<\/li><li>Experience with DCI\/DigiTrak or Underground Magnetics locating equipment.<\/li><li>Valid Class A CDL with air-brake experience.<\/li><li>Experience towing heavy equipment using a truck and trailer.<\/li><li>Familiarity with directional drilling, underground fiber, conduit, and utility construction.<\/li><li>Ability to operate a mud vacuum and assist with directional drill operations.<\/li><li>Strong communication skills and the ability to work effectively in a two-person crew.<\/li><li>Dependable attendance and the ability to report to the Harmony shop each morning.<\/li><li>Ability to work outdoors and perform physically demanding fieldwork.<\/li><\/ul>\n<p><\/p>\n<p><br>\n\n<\/p>","post_title":"Directional Drilling Locator","post_link":"https:\/\/turnerstaffing.com\/position\/directional-drilling-locator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"","%location_country%":"United States","%location_city%":"Harmony","%location_state_id%":"MN","%location_state_name%":"Minnesota","%location_city_state%":"Harmony, MN","%education%":"","%department%":"TSG","%description%":"<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking an experienced Directional Drill Locator to join a two-person horizontal directional drilling crew. This individual will work closely with an experienced drill operator to safely and accurately install underground fiber conduit and larger-diameter pipe.<\/p>\n<p>The ideal candidate can independently locate the drill head, operate supporting equipment, and transport the drill package using a Class A CDL.<\/p>\n<p><\/p>\n<p><strong>Responsibilities<\/strong><\/p>\n<ul><li>Track the drill head and communicate depth, pitch, roll, direction, and steering corrections to the drill operator.<\/li><li>Operate DCI\/DigiTrak and Underground Magnetics locating systems.<\/li><li>Review bore paths, utility markings, entry points, exit points, and required depths.<\/li><li>Maintain safe clearance from existing underground utilities.<\/li><li>Assist with pilot boring, backreaming, conduit installation, and pullback.<\/li><li>Operate a mud vacuum and support potholing, drilling-fluid management, and jobsite cleanup.<\/li><li>Assist with directional drill setup, operation, inspections, and basic maintenance.<\/li><li>Drive a Class A truck and trailer with air brakes to transport an approximately 40,000-pound drill package.<\/li><li>Complete approximately five drill shots per day, depending on project conditions.<\/li><li>Perform general field duties necessary to support the two-person crew.<\/li><\/ul>\n<p><\/p>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Previous HDD drill-locating experience.<\/li><li>Experience with DCI\/DigiTrak or Underground Magnetics locating equipment.<\/li><li>Valid Class A CDL with air-brake experience.<\/li><li>Experience towing heavy equipment using a truck and trailer.<\/li><li>Familiarity with directional drilling, underground fiber, conduit, and utility construction.<\/li><li>Ability to operate a mud vacuum and assist with directional drill operations.<\/li><li>Strong communication skills and the ability to work effectively in a two-person crew.<\/li><li>Dependable attendance and the ability to report to the Harmony shop each morning.<\/li><li>Ability to work outdoors and perform physically demanding fieldwork.<\/li><\/ul>\n<p><\/p>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/00eba0a10a70-directional-drilling-locator","%breezy_id%":"00eba0a10a70","%breezy_friendly_id%":"00eba0a10a70-directional-drilling-locator","%breezy_created_date%":"2026-07-13T20:22:48.573Z","%breezy_updated_date%":"2026-07-13T20:24:03.841Z","%_wpgmp_location_city%":"Harmony","%_wpgmp_location_state%":"MN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Harmony, MN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.5551811","%_wpgmp_metabox_longitude%":"-92.0052837","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"643"}},"id":3913,"infowindow_disable":false},{"source":"post","title":"Track Hoe Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Track Hoe Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are seeking an experienced and safety-driven Track Hoe Operator to support a client specializing in stream restoration&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/track-hoe-operator\/\" name=\"Track Hoe Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are seeking an experienced and safety-driven Track Hoe Operator to support a client specializing in stream restoration&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\/track-hoe-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are seeking an experienced and safety-driven Track Hoe Operator to support a client specializing in stream restoration&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Position Overview<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">We are seeking an experienced and safety-driven Track Hoe Operator to support a client specializing in stream restoration and environmental construction projects. This role is ideal for an operator with strong GPS machine control experience who can perform precise excavation and grading work in environmentally sensitive areas.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The successful candidate will have experience operating excavators in heavy civil, site development, utility, or stream restoration environments and will be comfortable working around waterways, wetlands, and uneven terrain. Attention to detail, grade accuracy, and a strong commitment to safety are essential.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate track hoes\/excavators safely and efficiently on stream restoration and environmental construction projects<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Utilize GPS machine control systems to perform accurate excavation, grading, and contouring work<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Read and interpret site plans, grade stakes, blueprints, and project specifications<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform stream channel shaping, bank stabilization, culvert installation, and erosion control activities<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Excavate around utilities and environmentally sensitive areas with precision<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct daily equipment inspections and basic preventive maintenance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate effectively with supervisors, grade checkers, and field crews to ensure project accuracy and productivity<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all company, client, OSHA, and environmental compliance standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with additional construction duties as needed to support project completion<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Minimum 3+ years of excavator\/track hoe operating experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous GPS machine control experience required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience in stream restoration, earthwork, utility, or heavy civil construction preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work from plans, elevations, and grade information<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of safe excavation practices<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Comfortable working in outdoor environments and varying weather conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver\u2019s license and reliable transportation required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to travel to project sites as needed<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred Skills<\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with Trimble, Topcon, or Leica GPS systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of erosion control and environmental compliance standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to operate additional heavy equipment is a plus<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">CDL preferred but not required<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical Requirements<\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to sit, stand, climb, and operate heavy equipment for extended periods<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to lift up to 50 pounds when necessary<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work on uneven ground and active construction sites<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Track Hoe Operator","post_link":"https:\/\/turnerstaffing.com\/position\/track-hoe-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"","%location_country%":"United States","%location_city%":"Ann Arbor","%location_state_id%":"MI","%location_state_name%":"Michigan","%location_city_state%":"Ann Arbor, MI","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Position Overview<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">We are seeking an experienced and safety-driven Track Hoe Operator to support a client specializing in stream restoration and environmental construction projects. This role is ideal for an operator with strong GPS machine control experience who can perform precise excavation and grading work in environmentally sensitive areas.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The successful candidate will have experience operating excavators in heavy civil, site development, utility, or stream restoration environments and will be comfortable working around waterways, wetlands, and uneven terrain. Attention to detail, grade accuracy, and a strong commitment to safety are essential.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate track hoes\/excavators safely and efficiently on stream restoration and environmental construction projects<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Utilize GPS machine control systems to perform accurate excavation, grading, and contouring work<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Read and interpret site plans, grade stakes, blueprints, and project specifications<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform stream channel shaping, bank stabilization, culvert installation, and erosion control activities<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Excavate around utilities and environmentally sensitive areas with precision<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct daily equipment inspections and basic preventive maintenance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate effectively with supervisors, grade checkers, and field crews to ensure project accuracy and productivity<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all company, client, OSHA, and environmental compliance standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with additional construction duties as needed to support project completion<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Minimum 3+ years of excavator\/track hoe operating experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous GPS machine control experience required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience in stream restoration, earthwork, utility, or heavy civil construction preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work from plans, elevations, and grade information<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of safe excavation practices<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Comfortable working in outdoor environments and varying weather conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver\u2019s license and reliable transportation required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to travel to project sites as needed<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Skills<\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with Trimble, Topcon, or Leica GPS systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of erosion control and environmental compliance standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to operate additional heavy equipment is a plus<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">CDL preferred but not required<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical Requirements<\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to sit, stand, climb, and operate heavy equipment for extended periods<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to lift up to 50 pounds when necessary<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work on uneven ground and active construction sites<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/eaf582a3cdb5-track-hoe-operator","%breezy_id%":"eaf582a3cdb5","%breezy_friendly_id%":"eaf582a3cdb5-track-hoe-operator","%breezy_created_date%":"2026-07-14T18:04:36.542Z","%breezy_updated_date%":"2026-07-23T15:07:43.993Z","%_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","%rank_math_analytic_object_id%":"645"}},"id":3915,"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\u2019s 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\u2019s 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\u2019s operations in Hinkley, California. This position plays a&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Overview<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is hiring General Laborers to support a client\u2019s 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform general labor duties including shoveling, cleanup, sweeping, and site housekeeping<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist crews with material handling, loading\/unloading, and jobsite preparation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support operators, maintenance personnel, and supervisors with daily operational needs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work safely around heavy equipment, machinery, and active work zones<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conduct routine inspections of work areas and report safety hazards or damaged equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain clean, organized, and hazard-free work environments<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all company safety policies, site procedures, and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Use hand tools and basic equipment safely and effectively<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform physically demanding work in outdoor and varying weather conditions<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous experience working in construction, mining, quarry, industrial, or outdoor labor environments preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong understanding of workplace safety practices and hazard awareness<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to lift, carry, bend, climb, and work on uneven terrain throughout the shift<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver\u2019s license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA certification preferred (or willingness to obtain prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in dusty, hot, cold, and physically demanding conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reliable transportation and dependable attendance required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to follow directions and work effectively as part of a team<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We\u2019re Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Hardworking individuals who are comfortable working outdoors in tough environments<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates with construction, mining, or heavy labor experience who understand jobsite safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Team players who can adapt to changing priorities and support multiple crews as needed<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Dependable workers who arrive ready to work safely and productively every day<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Individuals with a strong work ethic, positive attitude, and willingness to learn new skills<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Overview<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is hiring General Laborers to support a client\u2019s 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform general labor duties including shoveling, cleanup, sweeping, and site housekeeping<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist crews with material handling, loading\/unloading, and jobsite preparation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support operators, maintenance personnel, and supervisors with daily operational needs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work safely around heavy equipment, machinery, and active work zones<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conduct routine inspections of work areas and report safety hazards or damaged equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain clean, organized, and hazard-free work environments<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all company safety policies, site procedures, and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Use hand tools and basic equipment safely and effectively<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform physically demanding work in outdoor and varying weather conditions<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous experience working in construction, mining, quarry, industrial, or outdoor labor environments preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong understanding of workplace safety practices and hazard awareness<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to lift, carry, bend, climb, and work on uneven terrain throughout the shift<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver\u2019s license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA certification preferred (or willingness to obtain prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in dusty, hot, cold, and physically demanding conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reliable transportation and dependable attendance required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to follow directions and work effectively as part of a team<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We\u2019re Looking For<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Hardworking individuals who are comfortable working outdoors in tough environments<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates with construction, mining, or heavy labor experience who understand jobsite safety<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Team players who can adapt to changing priorities and support multiple crews as needed<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Dependable workers who arrive ready to work safely and productively every day<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Individuals with a strong work ethic, positive attitude, and willingness to learn new skills<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b6e8f40f88f0-laborer","%breezy_id%":"b6e8f40f88f0","%breezy_friendly_id%":"b6e8f40f88f0-laborer","%breezy_created_date%":"2026-07-14T21:32:28.732Z","%breezy_updated_date%":"2026-07-14T21:32:30.718Z","%_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","%rank_math_analytic_object_id%":"646"}},"id":3916,"infowindow_disable":false},{"source":"post","title":"Heavy Mobile Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Mobile Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You\u2019ll Be Doing Diagnose, repair, and maintain mobile equipment to ensure safe and reliable operation Perform inspections and identify&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-mobile-equipment-mechanic\/\" name=\"Heavy Mobile Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You\u2019ll Be Doing Diagnose, repair, and maintain mobile equipment to ensure safe and reliable operation Perform inspections and identify&hellip;","address":"Schoharie, NY, USA","location":{"lat":"42.6659087","city":"Schoharie","state":"NY","country":"United States","lng":"-74.3095787","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-mobile-equipment-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"What You\u2019ll Be Doing Diagnose, repair, and maintain mobile equipment to ensure safe and reliable operation Perform inspections and identify&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What You\u2019ll Be Doing<\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Diagnose, repair, and maintain mobile equipment to ensure safe and reliable<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">operation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform inspections and identify mechanical issues before they impact<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">production<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Document maintenance activities and communicate equipment status to<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">supervisors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Collaborate with operations teams to prioritize repairs and minimize downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow all safety procedures and contribute to a strong safety culture<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What Are We Looking For<\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong mechanical aptitude with the ability to troubleshoot and repair mobile<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Commitment to safe work practices and adherence to established procedures<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Capability to read and interpret technical manuals, diagrams, and work orders<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Effective communication skills and the ability to work independently or with a<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">team<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reliability, attention to detail, and adaptability in a fastpaced environment<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Conditions of Employment<\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Successful candidate must submit to post-offer pre-employment physical<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">examination, drug\/alcohol screen, and background check<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work Environment<\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Role operates primarily in environments where the conditions include moving<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">mechanical equipment, inclement weather, heat, cold, humidity, and elevated<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">noise level.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Heavy Mobile Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-mobile-equipment-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Schoharie","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Schoharie, NY","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What You\u2019ll Be Doing<\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Diagnose, repair, and maintain mobile equipment to ensure safe and reliable<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">operation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform inspections and identify mechanical issues before they impact<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">production<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Document maintenance activities and communicate equipment status to<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">supervisors<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Collaborate with operations teams to prioritize repairs and minimize downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow all safety procedures and contribute to a strong safety culture<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What Are We Looking For<\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong mechanical aptitude with the ability to troubleshoot and repair mobile<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Commitment to safe work practices and adherence to established procedures<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Capability to read and interpret technical manuals, diagrams, and work orders<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Effective communication skills and the ability to work independently or with a<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">team<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reliability, attention to detail, and adaptability in a fastpaced environment<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Conditions of Employment<\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Successful candidate must submit to post-offer pre-employment physical<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">examination, drug\/alcohol screen, and background check<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work Environment<\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Role operates primarily in environments where the conditions include moving<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">mechanical equipment, inclement weather, heat, cold, humidity, and elevated<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">noise level.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/dcd4e5790e9b-heavy-mobile-equipment-mechanic","%breezy_id%":"dcd4e5790e9b","%breezy_friendly_id%":"dcd4e5790e9b-heavy-mobile-equipment-mechanic","%breezy_created_date%":"2026-07-15T03:04:17.852Z","%breezy_updated_date%":"2026-08-19T18:04:08.784Z","%_wpgmp_location_city%":"Schoharie","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Schoharie, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6659087","%_wpgmp_metabox_longitude%":"-74.3095787","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"647"}},"id":3917,"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    Key Responsibilities Adhere to MSHA safety guidelines and company policies to ensure a safe and compliant work environment, prioritizing safety&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":"Key Responsibilities Adhere to MSHA safety guidelines and company policies to ensure a safe and compliant work environment, prioritizing safety&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\/heavy-equipment-mechanic-2\/","zoom":19,"extra_fields":{"post_excerpt":"Key Responsibilities Adhere to MSHA safety guidelines and company policies to ensure a safe and compliant work environment, prioritizing safety&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Adhere to MSHA safety guidelines and company policies to ensure a safe and compliant work environment, prioritizing safety at all times.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform daily inspections of plant crushing equipment, screening machinery, and conveyors to assess for wear and tear, documenting any parts or systems that require repair or servicing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Continuously monitor mobile equipment and systems to maintain an uninterrupted flow of materials. Take immediate corrective actions to clear any blockages and ensure smooth, continuous operations that meet production standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Support mobile maintenance management through comprehensive and accurate records, including daily maintenance logs, parts inventory, repair schedules, and service reports to ensure efficient operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Respond swiftly to mechanical breakdowns or failures to minimize downtime, ensuring quick restoration of mobile operations and consistent productivity.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Plan and execute routine preventive maintenance tasks to reduce equipment breakdowns and extend the lifespan of mobile machinery. Oversee greasing, lubrication, and minor repairs to keep all mobile equipment running efficiently.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">\u201cFit for Duty\u201d Requirements:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Medical Fitness: Applicants to whom the Company makes an offer must pass a \u201cFitness for Duty\u201d examination. The FFD examination may include a physical examination, drug\/alcohol screening, and respiratory function testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Essential Functions: Applicants must be able to perform the essential functions of the job, which include, but are not limited to: lifting up to 50 lbs., standing for extended periods, bending, reaching, and stooping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Failure to pass the \u201cFitness for Duty\u201d examination and \/or to demonstrate the ability to safely perform essential functions, may result in the Company withdrawing an offer of employment.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualification &amp; Experience<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">1+ year of rock quarry experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proven experience as a Quarry Mobile Mechanic or similar role in the maintenance of rock mobile machinery.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of mechanical, hydraulic, and pneumatic systems used in quarry operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong attention to detail, with excellent documentation and record-keeping skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to perform manual labor and operate heavy machinery as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA certification is preferred but not required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical Requirements<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must be able to lift up to 50 pounds occasionally<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must be able to sit or stand for extended periods and perform work on a computer<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical stamina and ability to work in various weather conditions.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Adhere to MSHA safety guidelines and company policies to ensure a safe and compliant work environment, prioritizing safety at all times.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform daily inspections of plant crushing equipment, screening machinery, and conveyors to assess for wear and tear, documenting any parts or systems that require repair or servicing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Continuously monitor mobile equipment and systems to maintain an uninterrupted flow of materials. Take immediate corrective actions to clear any blockages and ensure smooth, continuous operations that meet production standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Support mobile maintenance management through comprehensive and accurate records, including daily maintenance logs, parts inventory, repair schedules, and service reports to ensure efficient operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Respond swiftly to mechanical breakdowns or failures to minimize downtime, ensuring quick restoration of mobile operations and consistent productivity.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Plan and execute routine preventive maintenance tasks to reduce equipment breakdowns and extend the lifespan of mobile machinery. Oversee greasing, lubrication, and minor repairs to keep all mobile equipment running efficiently.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">\u201cFit for Duty\u201d Requirements:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Medical Fitness: Applicants to whom the Company makes an offer must pass a \u201cFitness for Duty\u201d examination. The FFD examination may include a physical examination, drug\/alcohol screening, and respiratory function testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Essential Functions: Applicants must be able to perform the essential functions of the job, which include, but are not limited to: lifting up to 50 lbs., standing for extended periods, bending, reaching, and stooping.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Failure to pass the \u201cFitness for Duty\u201d examination and \/or to demonstrate the ability to safely perform essential functions, may result in the Company withdrawing an offer of employment.&nbsp;<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualification &amp; Experience<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">1+ year of rock quarry experience required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proven experience as a Quarry Mobile Mechanic or similar role in the maintenance of rock mobile machinery.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of mechanical, hydraulic, and pneumatic systems used in quarry operations.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong attention to detail, with excellent documentation and record-keeping skills.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to perform manual labor and operate heavy machinery as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA certification is preferred but not required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical Requirements<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must be able to lift up to 50 pounds occasionally<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must be able to sit or stand for extended periods and perform work on a computer<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical stamina and ability to work in various weather conditions.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/2fc4ea369538-heavy-equipment-mechanic","%breezy_id%":"2fc4ea369538","%breezy_friendly_id%":"2fc4ea369538-heavy-equipment-mechanic","%breezy_created_date%":"2026-07-10T14:00:49.325Z","%breezy_updated_date%":"2026-07-10T14:00:51.763Z","%_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","%rank_math_analytic_object_id%":"637"}},"id":3907,"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    Key Responsibilities Operate off-road haul trucks in a safe and efficient manner Transport materials such as overburden, ore, and aggregate&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":"Key Responsibilities Operate off-road haul trucks in a safe and efficient manner Transport materials such as overburden, ore, and aggregate&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-2\/","zoom":19,"extra_fields":{"post_excerpt":"Key Responsibilities Operate off-road haul trucks in a safe and efficient manner Transport materials such as overburden, ore, and aggregate&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate off-road haul trucks in a safe and efficient manner<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Transport materials such as overburden, ore, and aggregate throughout the site<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform pre-shift and post-shift inspections on equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Report equipment issues, safety concerns, or hazards promptly<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain compliance with all site safety standards and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate effectively with dispatch, supervisors, and other operators<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with general site duties as needed<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Previous experience operating haul trucks in a mining, quarry, or heavy civil environment preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Valid driver\u2019s license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA certification (preferred; may be required prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in a physically demanding outdoor environment in varying weather conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong commitment to safety and following procedures<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Reliable transportation and consistent attendance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">What We\u2019re Looking For<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operators who take pride in running equipment safely and efficiently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Team players who can communicate and adapt in a fast-paced environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Individuals who are dependable and ready to work<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%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 style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate off-road haul trucks in a safe and efficient manner<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Transport materials such as overburden, ore, and aggregate throughout the site<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform pre-shift and post-shift inspections on equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Report equipment issues, safety concerns, or hazards promptly<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain compliance with all site safety standards and MSHA regulations<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate effectively with dispatch, supervisors, and other operators<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with general site duties as needed<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Previous experience operating haul trucks in a mining, quarry, or heavy civil environment preferred<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Valid driver\u2019s license required<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA certification (preferred; may be required prior to start)<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in a physically demanding outdoor environment in varying weather conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong commitment to safety and following procedures<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Reliable transportation and consistent attendance<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">What We\u2019re Looking For<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operators who take pride in running equipment safely and efficiently<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Team players who can communicate and adapt in a fast-paced environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Individuals who are dependable and ready to work<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/011d9cee3b77-haul-truck-driver","%breezy_id%":"011d9cee3b77","%breezy_friendly_id%":"011d9cee3b77-haul-truck-driver","%breezy_created_date%":"2026-07-10T14:08:33.855Z","%breezy_updated_date%":"2026-07-10T14:08:36.370Z","%_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","%rank_math_analytic_object_id%":"638"}},"id":3908,"infowindow_disable":false},{"source":"post","title":"Site Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Site Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Site Superintendent Position Overview We are seeking an experienced Civil Site Superintendent to lead large-scale site development projects from preconstruction&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/site-superintendent\/\" name=\"Site Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Site Superintendent Position Overview We are seeking an experienced Civil Site Superintendent to lead large-scale site development projects from preconstruction&hellip;","address":"Bownmansville, PA, USA","location":{"lat":"40.1967609","city":"Bownmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/site-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Site Superintendent Position Overview We are seeking an experienced Civil Site Superintendent to lead large-scale site development projects from preconstruction&hellip;","post_content":"<p><strong>Site Superintendent<\/strong><\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking an experienced Civil Site Superintendent to lead large-scale site development projects from preconstruction through completion. This role is ideal for a seasoned field leader with a strong background managing major civil\/site packages, including bulk earthwork, utilities, paving, grading, and complex phased construction.<\/p>\n<p>The Civil Site Superintendent will play a key role in both project pursuit and project execution. Before a project is awarded, this person may support estimating and operations by reviewing plans, helping evaluate workflow, identifying execution challenges, and providing field-based input on how the work should be planned and managed. Once awarded, the Superintendent will lead day-to-day field operations and ensure the project is delivered safely, efficiently, and to quality standards.<\/p>\n<p><\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Lead field operations for large civil\/site development projects, typically in the $10 million to $30 million+ range.<\/li><li>Manage complex site packages involving bulk earthwork, grading, utilities, pipe work, paving, stormwater, site preparation, and related scopes.<\/li><li>Support estimating and preconstruction teams by reviewing plans, evaluating constructability, identifying work sequencing, and providing input on project execution strategy.<\/li><li>Oversee daily site activities, crews, foremen, assistant superintendents, subcontractors, vendors, and field support personnel.<\/li><li>Coordinate closely with project managers, general superintendents, estimators, clients, engineers, inspectors, and general contractors.<\/li><li>Lead and mentor field personnel, including developing younger superintendents, foremen, operators, and assistant-level team members.<\/li><li>Track daily progress, materials, production, job logs, equipment usage, manpower, and field documentation.<\/li><li>Proactively identify and resolve field issues, schedule conflicts, plan discrepancies, and production obstacles.<\/li><li>Ensure work is performed according to plans, specifications, safety requirements, company standards, and client expectations.<\/li><\/ul>\n<p><\/p>\n<p><strong>Ideal Candidate Profile<\/strong><\/p>\n<p>The ideal candidate is a proven civil construction leader who has managed large, complex site packages from start to finish. This person should be comfortable stepping into high-value projects, working with estimating before award, building execution plans, and then leading the field once the project is active.<\/p>\n<p>Strong candidates may come from backgrounds such as:<\/p>\n<ul><li>Large commercial site development<\/li><li>Big-box warehouse site packages<\/li><li>Data center site preparation<\/li><li>Industrial site development<\/li><li>Large residential or multi-phase sitework<\/li><li>Heavy civil\/site construction<\/li><li>Bulk earthwork and mass grading<\/li><li>Utility and paving-heavy site packages<\/li><li><br><\/li><\/ul>\n<p>Direct data center experience is helpful but not required. Experience managing similar workflows, large earthmoving quantities, site utilities, paving, and phased site construction is more important.<\/p>\n<p><\/p>\n<p><strong>Required Qualifications<\/strong><\/p>\n<ul><li>Significant experience as a Civil Superintendent, Site Superintendent, or similar field leadership role.<\/li><li>Proven experience managing large sitework\/civil packages, preferably in the $10 million to $30 million+ range.<\/li><li>Strong background in bulk earthwork, grading, pipe, utilities, paving, and overall site development.<\/li><li>Experience managing large crews, field teams, subcontractors, and multiple scopes of work at once.<\/li><li>Ability to read and interpret civil plans, specifications, schedules, drawings, and project documents.<\/li><li>Ability to work with estimating and project management teams during pursuit, preconstruction, and execution.<\/li><li>Strong communication skills with field teams, office staff, owners, engineers, inspectors, and general contractors.<\/li><li>Safety-focused mindset and commitment to maintaining a clean, organized, and compliant jobsite.<\/li><\/ul>\n<p><strong>Preferred Qualifications<\/strong><\/p>\n<ul><li>Experience with large warehouse, logistics, industrial, or data center site development projects.<\/li><li>Experience managing projects involving 500,000+ cubic yards of earthwork.<\/li><li>Experience with large crews, including 25 to 50+ direct field employees and additional subcontractor personnel.<\/li><li>Experience with GPS machine control, drone-based quantity tracking, or production measurement tools.<\/li><li>Experience using Microsoft Project, Excel, Propeller, Trimble, B2W, HCSS, HeavyJob, iAuditor, or similar construction management platforms.<\/li><\/ul>\n<p><\/p>\n<p><strong>Compensation and Benefits<\/strong><\/p>\n<p>Compensation is open and will be based on experience, project background, and overall fit. The role is expected to come with a strong compensation package aligned with the level of responsibility and expectations.<\/p>\n<p>Additional benefits may include:<\/p>\n<ul><li>Company vehicle<\/li><li>Laptop and technology tools<\/li><li>Relocation support for qualified candidates<\/li><li>Long-term growth opportunity within operations, project management, estimating, or general superintendent leadership<\/li><\/ul>\n<p><\/p>\n<p><br>\n\n<\/p>","post_title":"Site Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/site-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bownmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bownmansville, PA","%education%":"","%department%":"TSG","%description%":"<p><strong>Site Superintendent<\/strong><\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking an experienced Civil Site Superintendent to lead large-scale site development projects from preconstruction through completion. This role is ideal for a seasoned field leader with a strong background managing major civil\/site packages, including bulk earthwork, utilities, paving, grading, and complex phased construction.<\/p>\n<p>The Civil Site Superintendent will play a key role in both project pursuit and project execution. Before a project is awarded, this person may support estimating and operations by reviewing plans, helping evaluate workflow, identifying execution challenges, and providing field-based input on how the work should be planned and managed. Once awarded, the Superintendent will lead day-to-day field operations and ensure the project is delivered safely, efficiently, and to quality standards.<\/p>\n<p><\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Lead field operations for large civil\/site development projects, typically in the $10 million to $30 million+ range.<\/li><li>Manage complex site packages involving bulk earthwork, grading, utilities, pipe work, paving, stormwater, site preparation, and related scopes.<\/li><li>Support estimating and preconstruction teams by reviewing plans, evaluating constructability, identifying work sequencing, and providing input on project execution strategy.<\/li><li>Oversee daily site activities, crews, foremen, assistant superintendents, subcontractors, vendors, and field support personnel.<\/li><li>Coordinate closely with project managers, general superintendents, estimators, clients, engineers, inspectors, and general contractors.<\/li><li>Lead and mentor field personnel, including developing younger superintendents, foremen, operators, and assistant-level team members.<\/li><li>Track daily progress, materials, production, job logs, equipment usage, manpower, and field documentation.<\/li><li>Proactively identify and resolve field issues, schedule conflicts, plan discrepancies, and production obstacles.<\/li><li>Ensure work is performed according to plans, specifications, safety requirements, company standards, and client expectations.<\/li><\/ul>\n<p><\/p>\n<p><strong>Ideal Candidate Profile<\/strong><\/p>\n<p>The ideal candidate is a proven civil construction leader who has managed large, complex site packages from start to finish. This person should be comfortable stepping into high-value projects, working with estimating before award, building execution plans, and then leading the field once the project is active.<\/p>\n<p>Strong candidates may come from backgrounds such as:<\/p>\n<ul><li>Large commercial site development<\/li><li>Big-box warehouse site packages<\/li><li>Data center site preparation<\/li><li>Industrial site development<\/li><li>Large residential or multi-phase sitework<\/li><li>Heavy civil\/site construction<\/li><li>Bulk earthwork and mass grading<\/li><li>Utility and paving-heavy site packages<\/li><li><br><\/li><\/ul>\n<p>Direct data center experience is helpful but not required. Experience managing similar workflows, large earthmoving quantities, site utilities, paving, and phased site construction is more important.<\/p>\n<p><\/p>\n<p><strong>Required Qualifications<\/strong><\/p>\n<ul><li>Significant experience as a Civil Superintendent, Site Superintendent, or similar field leadership role.<\/li><li>Proven experience managing large sitework\/civil packages, preferably in the $10 million to $30 million+ range.<\/li><li>Strong background in bulk earthwork, grading, pipe, utilities, paving, and overall site development.<\/li><li>Experience managing large crews, field teams, subcontractors, and multiple scopes of work at once.<\/li><li>Ability to read and interpret civil plans, specifications, schedules, drawings, and project documents.<\/li><li>Ability to work with estimating and project management teams during pursuit, preconstruction, and execution.<\/li><li>Strong communication skills with field teams, office staff, owners, engineers, inspectors, and general contractors.<\/li><li>Safety-focused mindset and commitment to maintaining a clean, organized, and compliant jobsite.<\/li><\/ul>\n<p><strong>Preferred Qualifications<\/strong><\/p>\n<ul><li>Experience with large warehouse, logistics, industrial, or data center site development projects.<\/li><li>Experience managing projects involving 500,000+ cubic yards of earthwork.<\/li><li>Experience with large crews, including 25 to 50+ direct field employees and additional subcontractor personnel.<\/li><li>Experience with GPS machine control, drone-based quantity tracking, or production measurement tools.<\/li><li>Experience using Microsoft Project, Excel, Propeller, Trimble, B2W, HCSS, HeavyJob, iAuditor, or similar construction management platforms.<\/li><\/ul>\n<p><\/p>\n<p><strong>Compensation and Benefits<\/strong><\/p>\n<p>Compensation is open and will be based on experience, project background, and overall fit. The role is expected to come with a strong compensation package aligned with the level of responsibility and expectations.<\/p>\n<p>Additional benefits may include:<\/p>\n<ul><li>Company vehicle<\/li><li>Laptop and technology tools<\/li><li>Relocation support for qualified candidates<\/li><li>Long-term growth opportunity within operations, project management, estimating, or general superintendent leadership<\/li><\/ul>\n<p><\/p>\n<p><br>\n\n<\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a7fa678bb101-site-superintendent","%breezy_id%":"a7fa678bb101","%breezy_friendly_id%":"a7fa678bb101-site-superintendent","%breezy_created_date%":"2026-07-10T14:50:55.239Z","%breezy_updated_date%":"2026-07-10T14:51:48.289Z","%_wpgmp_location_city%":"Bownmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bownmansville, 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%":"639"}},"id":3909,"infowindow_disable":false},{"source":"post","title":"Diesel Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Diesel Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You Will Do Perform diagnostic, maintenance and repair of heavy equipment such as, but not limited to: Haul Trucks,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/diesel-mechanic\/\" name=\"Diesel Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You Will Do Perform diagnostic, maintenance and repair of heavy equipment such as, but not limited to: Haul Trucks,&hellip;","address":"Leadville, CO, USA","location":{"lat":"39.248728","city":"Leadville","state":"CO","country":"United States","lng":"-106.2918815","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/diesel-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"What You Will Do Perform diagnostic, maintenance and repair of heavy equipment such as, but not limited to: Haul Trucks,&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Will Do<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform diagnostic, maintenance and repair of heavy equipment such as, but not limited to: Haul Trucks, Water Trucks, Rubber Tire and Track Dozers, Front-end Loaders, and Motor Graders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform the removal, repair and installation of transmissions, engines, breaks, differentials, pumps, motors, torque convertors, final drives and other heavy equipment systems or components.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform mechanical and lubrication preventative maintenance on machine systems such as: hydraulic, power train and engines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prioritize and make decisions regarding equipment repair as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsible for maintaining work orders and performing work area inspections.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Operate mobile equipment such as: Overhead cranes, forklifts, and boom trucks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform welding such as: Carbon arc, Plasma, Mig, Tig, and Stick.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform as a Fill-in Supervisor as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Train and mentor other employees.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform other duties as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Bring To Freeport<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Two (2) years\u2019 experience in mechanical\/maintenance crafts (including welder, boilermaker, machinist or facility maintenance\/construction) or a combination of education and experience in industrial mechanical repair and maintenance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have completed academic and practical competencies required (this includes Line of Progression requirements for internal employees where LOP Exists) and have experience demonstrating the required mechanical aptitude.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">HEM Diagnostic Mechanic I: Practical Skills Assessments defined in LOP.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to understand and apply verbal and written work and safety-related instructions and procedures in English<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to communicate in English with respect to job assignments, job procedures, and applicable safety standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to prioritize repairs and possess excellent decision-making skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to troubleshoot machine systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work and effectively communicate with others<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to read and use blueprints<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Preferred Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High School Diploma or GED<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We Offer You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong> <\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The estimated pay range for this role is currently<strong>\u202f$30.50 - $40.50 hour.<\/strong> This range reflects base salary only and does not include bonus payments, benefits or retirement contributions. Actual base pay is determined by experience, qualifications, skills and other job-related factors. This role is eligible for additional discretionary and incentive payment considerations based on company and individual performance. More details will be shared during the hiring process.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employees who are required to work on-site are eligible for a $1,450 monthly housing allowance, provided they meet program guidelines<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Affordable medical, dental and vision benefits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Company-paid life and disability insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">401(k) plan with employer contribution\/match<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Paid time off, paid sick time, holiday pay, parental leave<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Tuition assistance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employee Assistance Program<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Discounted insurance plans for pet, auto, home and vehicle<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Internal progression opportunities<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We Require <\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates may be required to pass a medical exam.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must pass all required training and\/or testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employees may be required to work a non-standard schedule, which may include shift work (other than day shift) at a 24\/7, 365-day operation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"> Mandatory pre-employment drug testing and on-going drug and alcohol testing, as allowed by applicable laws.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Diesel Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/diesel-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Leadville","%location_state_id%":"CO","%location_state_name%":"Colorado","%location_city_state%":"Leadville, CO","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Will Do<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform diagnostic, maintenance and repair of heavy equipment such as, but not limited to: Haul Trucks, Water Trucks, Rubber Tire and Track Dozers, Front-end Loaders, and Motor Graders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform the removal, repair and installation of transmissions, engines, breaks, differentials, pumps, motors, torque convertors, final drives and other heavy equipment systems or components.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform mechanical and lubrication preventative maintenance on machine systems such as: hydraulic, power train and engines.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prioritize and make decisions regarding equipment repair as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsible for maintaining work orders and performing work area inspections.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Operate mobile equipment such as: Overhead cranes, forklifts, and boom trucks.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform welding such as: Carbon arc, Plasma, Mig, Tig, and Stick.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform as a Fill-in Supervisor as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Train and mentor other employees.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform other duties as required.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Bring To Freeport<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Two (2) years\u2019 experience in mechanical\/maintenance crafts (including welder, boilermaker, machinist or facility maintenance\/construction) or a combination of education and experience in industrial mechanical repair and maintenance.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have completed academic and practical competencies required (this includes Line of Progression requirements for internal employees where LOP Exists) and have experience demonstrating the required mechanical aptitude.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">HEM Diagnostic Mechanic I: Practical Skills Assessments defined in LOP.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to understand and apply verbal and written work and safety-related instructions and procedures in English<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to communicate in English with respect to job assignments, job procedures, and applicable safety standards<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to prioritize repairs and possess excellent decision-making skills<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to troubleshoot machine systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work and effectively communicate with others<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to read and use blueprints<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Preferred Qualifications<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\"><li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High School Diploma or GED<\/li><\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We Offer You<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong> <\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The estimated pay range for this role is currently<strong>\u202f$30.50 - $40.50 hour.<\/strong> This range reflects base salary only and does not include bonus payments, benefits or retirement contributions. Actual base pay is determined by experience, qualifications, skills and other job-related factors. This role is eligible for additional discretionary and incentive payment considerations based on company and individual performance. More details will be shared during the hiring process.<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employees who are required to work on-site are eligible for a $1,450 monthly housing allowance, provided they meet program guidelines<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Affordable medical, dental and vision benefits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Company-paid life and disability insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">401(k) plan with employer contribution\/match<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Paid time off, paid sick time, holiday pay, parental leave<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Tuition assistance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employee Assistance Program<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Discounted insurance plans for pet, auto, home and vehicle<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Internal progression opportunities<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We Require <\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates may be required to pass a medical exam.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must pass all required training and\/or testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employees may be required to work a non-standard schedule, which may include shift work (other than day shift) at a 24\/7, 365-day operation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"> Mandatory pre-employment drug testing and on-going drug and alcohol testing, as allowed by applicable laws.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/47a6def8ac7e-diesel-mechanic","%breezy_id%":"47a6def8ac7e","%breezy_friendly_id%":"47a6def8ac7e-diesel-mechanic","%breezy_created_date%":"2026-07-10T17:41:43.276Z","%breezy_updated_date%":"2026-07-10T17:41:45.726Z","%_wpgmp_location_city%":"Leadville","%_wpgmp_location_state%":"CO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Leadville, CO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.248728","%_wpgmp_metabox_longitude%":"-106.2918815","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"640"}},"id":3910,"infowindow_disable":false},{"source":"post","title":"CDL Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    CDL Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You&#8217;ll Be Doing Safely operate a ready mix truck to deliver concrete to customer job sites Perform pre-trip and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/cdl-driver\/\" name=\"CDL Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You&#8217;ll Be Doing Safely operate a ready mix truck to deliver concrete to customer job sites Perform pre-trip and&hellip;","address":"Pittsburgh, PA, USA","location":{"lat":"40.4386612","city":"Pittsburgh","state":"PA","country":"United States","lng":"-79.9972352","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/cdl-driver\/","zoom":19,"extra_fields":{"post_excerpt":"What You&#8217;ll Be Doing Safely operate a ready mix truck to deliver concrete to customer job sites Perform pre-trip and&hellip;","post_content":"<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><strong>What You'll Be Doing<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Safely operate a ready mix truck to deliver concrete to customer job sites<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Perform pre-trip and post-trip inspections and maintain vehicle cleanliness<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Communicate effectively with dispatch and customers to ensure timely deliveries<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Assist with yard duties and minor maintenance as needed<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Adhere to all safety protocols and company procedures<\/li>\n<\/ul>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><strong>What Are We Looking For<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Valid CDL Class B or A with air brake endorsement<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Ability to operate commercial vehicles safely and efficiently<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Strong communication and teamwork skills<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Commitment to punctuality and reliability<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Capability to work in a physically demanding and fast-paced environment<\/li>\n<\/ul>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><strong>Conditions of Employment<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li>\n<\/ul>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><strong>Work Environment<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\"><li data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><br><\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><br><\/p>","post_title":"CDL Driver","post_link":"https:\/\/turnerstaffing.com\/position\/cdl-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Pittsburgh","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Pittsburgh, PA","%education%":"","%department%":"TSG","%description%":"<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><strong>What You'll Be Doing<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Safely operate a ready mix truck to deliver concrete to customer job sites<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Perform pre-trip and post-trip inspections and maintain vehicle cleanliness<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Communicate effectively with dispatch and customers to ensure timely deliveries<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Assist with yard duties and minor maintenance as needed<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Adhere to all safety protocols and company procedures<\/li>\n<\/ul>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><strong>What Are We Looking For<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Valid CDL Class B or A with air brake endorsement<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Ability to operate commercial vehicles safely and efficiently<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Strong communication and teamwork skills<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Commitment to punctuality and reliability<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Capability to work in a physically demanding and fast-paced environment<\/li>\n<\/ul>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><strong>Conditions of Employment<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li>\n<li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li>\n<\/ul>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><strong>Work Environment<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\"><li data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><br><\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/dbada4212d4b-cdl-driver","%breezy_id%":"dbada4212d4b","%breezy_friendly_id%":"dbada4212d4b-cdl-driver","%breezy_created_date%":"2026-07-10T17:49:37.261Z","%breezy_updated_date%":"2026-09-08T22:08:56.411Z","%_wpgmp_location_city%":"Pittsburgh","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pittsburgh, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.4386612","%_wpgmp_metabox_longitude%":"-79.9972352","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"641"}},"id":3911,"infowindow_disable":false},{"source":"post","title":"Industrial Maintenance Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Maintenance Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Where You Will Work Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations (an open-pit&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-maintenance-electrician\/\" name=\"Industrial Maintenance Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Where You Will Work Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations (an open-pit&hellip;","address":"Morenci, AZ, USA","location":{"lat":"33.0508859","city":"Morenci","state":"AZ","country":"United States","lng":"-109.3280282","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-maintenance-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"Where You Will Work Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations (an open-pit&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Where You Will Work<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations (an open-pit copper mining complex) has been in continuous operation since 1939. The operation consists of two concentrators, crushed-ore leach pad and stacking system, a low-grade run-of-mine (ROM) leaching system; four SX plants; and three EW tank houses that produce copper cathode.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Morenci is a unique company town where our employees and their families can reconnect with nature through hiking, fishing, camping, hunting and numerous parks. The company offers several amenities, including company housing, OR employees who are required to work on-site are eligible for a $750 monthly housing allowance, provided they meet program guidelines, a newly constructed daycare and community center, library, health-care facilities, state-of-the-art fitness centers, a movie theater and a skate park. Our dedicated Parks and Recreation Division plans activities for people of all ages, making sure there\u2019s something for everyone to enjoy. Visit the Morenci town\u202f<a data-faitracker-click-bind=\"true\" href=\"https:\/\/www.morencitown.com\/dining\" target=\"_blank\">website<\/a>\u202fto learn more.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Will Do<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Removal, repair and installation of electrical components, electrical systems, analysis and diagnosis, advanced troubleshooting and systems\/process optimization; may mentor or train other electrical workers.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safe completion of routine and non-routine repairs and construction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform preventative maintenance including installation, repair and troubleshooting of industrial electrical and\/or instrumentation equipment (i.e. substations, power distribution systems, switchgear motors, motor controls, systems and components, process controls, instrumentation and pneumatic equipment).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have strong knowledge in the maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, management control systems, calibration of field transmitters\/transducers and weigh scales, and low and medium voltage equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to perform installations and renovations compliant with regulatory agency standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Follow Standard Operating Procedures (SOP) and work area instructions, participate in safety and environmental activities, and use plant and equipment correctly at all times.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Additional responsibilities and duties may be assigned according to business need.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What You Bring To Freeport<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Completion of an approved Certified Electronics, Electrical and\/or Instrumentation Program,<strong>\u202fOR <\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Minimum of four (4) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance,<strong>\u202fOR <\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Associate's degree or Trade School Certification in a related field\u202f<strong>and<\/strong>\u202ftwo (2) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience in troubleshooting, maintenance and repair of electrical circuits and connected equipment; this includes the ability to read, understand and apply information from technical manuals, prints, and schematics for trouble shooting and repair.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Effective written and verbal communication skills to satisfy training, safety, and electronic message transmission policies of the company.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have minimum personal tools as described by the department tool list or be able to obtain them within 90 days of hire date.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must have completed academic and practical competencies required (this includes Line of Progression requirements for internal employees where LOP Exists) and have experience demonstrating the required aptitude. The selected candidate shall demonstrate the ability to apply knowledge and skills while also passing a written assessment where required. This exam is based on skills\/abilities and\/or academic knowledge, as well as safety.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Preferred Qualifications<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">High School diploma or GED<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with VFDs, PLC, HMI, and\/or SCADA Control Systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience working with low and medium voltages.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with AC and\/or DC controls<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with instrumentation devices<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with diagnostic electrical test equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with HVAC equipment<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We Offer You <\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">The estimated pay range for this role is currently\u202f<strong>$33.00 - $45.00\/hour.<\/strong> This range reflects base salary only and does not include bonus payments, benefits or retirement contributions. Actual base pay is determined by experience, qualifications, skills and other job-related factors. This role is eligible for additional discretionary and incentive payment considerations based on company and individual performance. More details will be shared during the hiring process.<\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employees who are required to work on-site are eligible for a $750 monthly housing allowance, provided they meet program guidelines<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Affordable medical, dental and vision benefits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Company-paid life and disability insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">401(k) plan with employer contribution\/match<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Paid time off, paid sick time, holiday pay, parental leave<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Tuition assistance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employee Assistance Program<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Discounted insurance plans for pet, auto, home and vehicle<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Internal progression opportunities<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>What We Require <\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates may be required to pass a medical exam.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Candidates must pass all required training and\/or testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employees may be required to work a non-standard schedule, which may include shift work (other than day shift) at a 24\/7, 365-day operation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Mandatory pre-employment drug testing and on-going random drug testing as allowed by applicable state laws.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Industrial Maintenance Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-maintenance-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Morenci","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Morenci, AZ","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Where You Will Work<\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Located approximately 50 miles northeast of Safford, Arizona on U.S. Highway 191, Morenci operations (an open-pit copper mining complex) has been in continuous operation since 1939. The operation consists of two concentrators, crushed-ore leach pad and stacking system, a low-grade run-of-mine (ROM) leaching system; four SX plants; and three EW tank houses that produce copper cathode.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Morenci is a unique company town where our employees and their families can reconnect with nature through hiking, fishing, camping, hunting and numerous parks. The company offers several amenities, including company housing, OR employees who are required to work on-site are eligible for a $750 monthly housing allowance, provided they meet program guidelines, a newly constructed daycare and community center, library, health-care facilities, state-of-the-art fitness centers, a movie theater and a skate park. Our dedicated Parks and Recreation Division plans activities for people of all ages, making sure there\u2019s something for everyone to enjoy. Visit the Morenci town\u202f<a data-faitracker-click-bind=\"true\" href=\"https:\/\/www.morencitown.com\/dining\" target=\"_blank\">website<\/a>\u202fto learn more.<\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Will Do<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Removal, repair and installation of electrical components, electrical systems, analysis and diagnosis, advanced troubleshooting and systems\/process optimization; may mentor or train other electrical workers.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safe completion of routine and non-routine repairs and construction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform preventative maintenance including installation, repair and troubleshooting of industrial electrical and\/or instrumentation equipment (i.e. substations, power distribution systems, switchgear motors, motor controls, systems and components, process controls, instrumentation and pneumatic equipment).<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have strong knowledge in the maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, management control systems, calibration of field transmitters\/transducers and weigh scales, and low and medium voltage equipment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to perform installations and renovations compliant with regulatory agency standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Follow Standard Operating Procedures (SOP) and work area instructions, participate in safety and environmental activities, and use plant and equipment correctly at all times.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Additional responsibilities and duties may be assigned according to business need.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What You Bring To Freeport<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Completion of an approved Certified Electronics, Electrical and\/or Instrumentation Program,<strong>\u202fOR <\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Minimum of four (4) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance,<strong>\u202fOR <\/strong>\n<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Associate's degree or Trade School Certification in a related field\u202f<strong>and<\/strong>\u202ftwo (2) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience in troubleshooting, maintenance and repair of electrical circuits and connected equipment; this includes the ability to read, understand and apply information from technical manuals, prints, and schematics for trouble shooting and repair.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Effective written and verbal communication skills to satisfy training, safety, and electronic message transmission policies of the company.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have minimum personal tools as described by the department tool list or be able to obtain them within 90 days of hire date.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must have completed academic and practical competencies required (this includes Line of Progression requirements for internal employees where LOP Exists) and have experience demonstrating the required aptitude. The selected candidate shall demonstrate the ability to apply knowledge and skills while also passing a written assessment where required. This exam is based on skills\/abilities and\/or academic knowledge, as well as safety.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Preferred Qualifications<\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">High School diploma or GED<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with VFDs, PLC, HMI, and\/or SCADA Control Systems<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience working with low and medium voltages.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with AC and\/or DC controls<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with instrumentation devices<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with diagnostic electrical test equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with HVAC equipment<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We Offer You <\/strong><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">The estimated pay range for this role is currently\u202f<strong>$33.00 - $45.00\/hour.<\/strong> This range reflects base salary only and does not include bonus payments, benefits or retirement contributions. Actual base pay is determined by experience, qualifications, skills and other job-related factors. This role is eligible for additional discretionary and incentive payment considerations based on company and individual performance. More details will be shared during the hiring process.<\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employees who are required to work on-site are eligible for a $750 monthly housing allowance, provided they meet program guidelines<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Affordable medical, dental and vision benefits<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Company-paid life and disability insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">401(k) plan with employer contribution\/match<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Paid time off, paid sick time, holiday pay, parental leave<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Tuition assistance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employee Assistance Program<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Discounted insurance plans for pet, auto, home and vehicle<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Internal progression opportunities<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>What We Require <\/strong><\/p>\n<ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates may be required to pass a medical exam.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Candidates must pass all required training and\/or testing.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employees may be required to work a non-standard schedule, which may include shift work (other than day shift) at a 24\/7, 365-day operation.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Mandatory pre-employment drug testing and on-going random drug testing as allowed by applicable state laws.<\/li>\n<\/ul>\n<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/d46488867ef9-industrial-maintenance-electrician","%breezy_id%":"d46488867ef9","%breezy_friendly_id%":"d46488867ef9-industrial-maintenance-electrician","%breezy_created_date%":"2026-07-13T16:38:16.845Z","%breezy_updated_date%":"2026-07-23T15:10:35.157Z","%_wpgmp_location_city%":"Morenci","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Morenci, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.0508859","%_wpgmp_metabox_longitude%":"-109.3280282","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"642"}},"id":3912,"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\/c3d03a4efe0c-haul-truck-operator-mining","%breezy_id%":"c3d03a4efe0c","%breezy_friendly_id%":"c3d03a4efe0c-haul-truck-operator-mining","%breezy_created_date%":"2026-07-08T17:43:47.426Z","%breezy_updated_date%":"2026-07-10T12:31:54.499Z","%_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","%rank_math_analytic_object_id%":"631"}},"id":3901,"infowindow_disable":false},{"source":"post","title":"Design Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Design Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a Design Consultant\/Engineer for our client to support the planning, design, and coordination of electrical&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/design-engineer\/\" name=\"Design Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a Design Consultant\/Engineer for our client to support the planning, design, and coordination of electrical&hellip;","address":"Tempe, AZ, USA","location":{"lat":"33.4255104","city":"Tempe","state":"AZ","country":"United States","lng":"-111.9400054","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/design-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a Design Consultant\/Engineer for our client to support the planning, design, and coordination of electrical&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Turner Staffing Group is seeking a <strong>Design Consultant\/Engineer for our client to support the planning, design, and coordination of electrical distribution projects. This role serves as a key liaison between customers, contractors, engineers, and internal stakeholders to deliver safe, accurate, and cost-effective electrical facility designs while ensuring compliance with company standards and municipal requirements.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Coordinate and collaborate with construction, engineering, land agents, survey teams, customers, contractors, developers, property owners, and other internal and external stakeholders to develop electrical facility designs that meet safety, quality, and engineering standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Serve as the primary point of contact throughout the design process, maintaining clear communication with customers, contractors, developers, and project stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Manage project expectations, including schedules, service level agreements, deliverables, costs, responsibilities, and safety requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Partner closely with CAD Technicians by providing preliminary design sketches, establishing priorities and deadlines, monitoring progress, and reviewing completed drawings for accuracy and quality.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Utilize CAD tools to support and review electrical distribution designs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Read, interpret, and apply a variety of plan sets and mapping resources, including electrical, civil, architectural, structural, geographic, municipal, and customer-provided documents.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform field visits to verify site conditions, validate reference maps, identify design constraints, and confirm project scope.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Independently prioritize workload and determine when projects are ready to advance through the design process.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain accurate project documentation and tracking using the Work Management System while ensuring compliance with established procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assign, monitor, and manage project milestones and due dates for internal teams and external stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Oversee design activities specific to assigned business processes and ensure timely project completion.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Prepare material lists and inventories required for construction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Calculate design and construction costs in accordance with company policies and prepare accurate design agreements and construction contracts.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure designs comply with municipal permitting requirements, construction and engineering standards, engineering tools, and land rights requirements to facilitate successful permit approvals.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Assist with training and mentoring other design team members as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Identify and resolve job-site hazards and encroachment issues.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Demonstrate knowledge of electrical distribution systems, including applicable components and conductor types.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Provide detailed project documentation, history, and technical knowledge as requested.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Design Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/design-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Tempe","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tempe, AZ","%education%":"","%department%":"TSG","%description%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Turner Staffing Group is seeking a <strong>Design Consultant\/Engineer for our client to support the planning, design, and coordination of electrical distribution projects. This role serves as a key liaison between customers, contractors, engineers, and internal stakeholders to deliver safe, accurate, and cost-effective electrical facility designs while ensuring compliance with company standards and municipal requirements.<\/strong><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><strong>Key Responsibilities<\/strong><\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Coordinate and collaborate with construction, engineering, land agents, survey teams, customers, contractors, developers, property owners, and other internal and external stakeholders to develop electrical facility designs that meet safety, quality, and engineering standards.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Serve as the primary point of contact throughout the design process, maintaining clear communication with customers, contractors, developers, and project stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Manage project expectations, including schedules, service level agreements, deliverables, costs, responsibilities, and safety requirements.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Partner closely with CAD Technicians by providing preliminary design sketches, establishing priorities and deadlines, monitoring progress, and reviewing completed drawings for accuracy and quality.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Utilize CAD tools to support and review electrical distribution designs.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Read, interpret, and apply a variety of plan sets and mapping resources, including electrical, civil, architectural, structural, geographic, municipal, and customer-provided documents.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform field visits to verify site conditions, validate reference maps, identify design constraints, and confirm project scope.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Independently prioritize workload and determine when projects are ready to advance through the design process.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain accurate project documentation and tracking using the Work Management System while ensuring compliance with established procedures.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assign, monitor, and manage project milestones and due dates for internal teams and external stakeholders.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Oversee design activities specific to assigned business processes and ensure timely project completion.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Prepare material lists and inventories required for construction.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Calculate design and construction costs in accordance with company policies and prepare accurate design agreements and construction contracts.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure designs comply with municipal permitting requirements, construction and engineering standards, engineering tools, and land rights requirements to facilitate successful permit approvals.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Assist with training and mentoring other design team members as needed.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Identify and resolve job-site hazards and encroachment issues.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Demonstrate knowledge of electrical distribution systems, including applicable components and conductor types.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Provide detailed project documentation, history, and technical knowledge as requested.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/4398d66a3c62-design-engineer","%breezy_id%":"4398d66a3c62","%breezy_friendly_id%":"4398d66a3c62-design-engineer","%breezy_created_date%":"2026-07-09T12:57:20.021Z","%breezy_updated_date%":"2026-07-09T12:57:21.958Z","%_wpgmp_location_city%":"Tempe","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tempe, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4255104","%_wpgmp_metabox_longitude%":"-111.9400054","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"632"}},"id":3902,"infowindow_disable":false},{"source":"post","title":"Senior Accountant","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Accountant\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Responsibilities \uf0b7 Coordinate and support the company&#8217;s accounting and financial reporting functions, including cost accounting activities. \uf0b7 Maintain accounting records,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-accountant\/\" name=\"Senior Accountant\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Responsibilities \uf0b7 Coordinate and support the company&#8217;s accounting and financial reporting functions, including cost accounting activities. \uf0b7 Maintain accounting records,&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\/senior-accountant\/","zoom":19,"extra_fields":{"post_excerpt":"Responsibilities \uf0b7 Coordinate and support the company&#8217;s accounting and financial reporting functions, including cost accounting activities. \uf0b7 Maintain accounting records,&hellip;","post_content":"<p>Responsibilities<\/p>\n<p>\uf0b7 Coordinate and support the company's accounting and financial reporting functions,<\/p>\n<p>including cost accounting activities.<\/p>\n<p>\uf0b7 Maintain accounting records, general ledger accounts, and supporting documentation in<\/p>\n<p>accordance with IFRS, GAAP, and Company policies.<\/p>\n<p>\uf0b7 Assist with month-end, quarter-end, and year-end close processes, including journal<\/p>\n<p>entries, accruals, reconciliations, and financial reporting.<\/p>\n<p>\uf0b7 Prepare and analyze account reconciliations, investigate variances, and proactively<\/p>\n<p>resolve discrepancies.<\/p>\n<p>\uf0b7 Assist in the preparation of monthly financial statements and management reporting<\/p>\n<p>packages.<\/p>\n<p>\uf0b7 Support internal and external audits by coordinating schedules, documentation, and<\/p>\n<p>audit requests.<\/p>\n<p>\uf0b7 Assist with compliance related to federal, state, local, payroll, sales\/use, and other<\/p>\n<p>applicable taxes.<\/p>\n<p>\uf0b7 Perform cost accounting activities, including cost variance analysis, inventory valuation,<\/p>\n<p>and operational cost reporting.<\/p>\n<p>\uf0b7 Support material inventory controls, including validation of inventory transactions and<\/p>\n<p>periodic inventory counts.<\/p>\n<p>\uf0b7 Review purchasing and procurement transactions to ensure proper accounting<\/p>\n<p>treatment and compliance with Company policies.<\/p>\n<p>JOB DESCRIPTION<\/p>\n<p>\uf0b7 Maintain fixed asset records, including capital project tracking (CIP), depreciation, asset<\/p>\n<p>additions, disposals, and annual physical inventories.<\/p>\n<p>\uf0b7 Assist with internal control compliance, documentation, and continuous improvement<\/p>\n<p>initiatives.<\/p>\n<p>\uf0b7 Support accounts payable, accounts receivable, payroll, treasury, and other accounting<\/p>\n<p>functions as needed to ensure business continuity and operational success.<\/p>\n<p>\uf0b7 Prepare and distribute financial reports, schedules, and supporting analyses for<\/p>\n<p>management and corporate reporting.<\/p>\n<p>\uf0b7 Build strong working relationships across operations, maintenance, supply chain,<\/p>\n<p>technical services, and corporate finance teams.<\/p>\n<p>\uf0b7 Contribute ideas and actions toward process improvements that enhance efficiency,<\/p>\n<p>accuracy, and financial controls.<\/p>\n<p>\uf0b7 Participate in special projects and other duties as assigned.<\/p>\n<p>The above responsibilities are representative and may not include all assigned duties.<\/p>\n<p>Education and Experience<\/p>\n<p>\u2022 Bachelor\u2019s degree in accounting or related field required.<\/p>\n<p>\u2022 5+ years of progressive accounting experience required.<\/p>\n<p>\u2022 CPA, CMA, or CPA-track strongly preferred.<\/p>\n<p>\u2022 Experience with financial reporting, month-end close, account reconciliations, and<\/p>\n<p>internal controls required.<\/p>\n<p>\u2022 Experience with cost accounting, inventory accounting, fixed assets, or capital project<\/p>\n<p>accounting preferred.<\/p>\n<p>\u2022 Mining, manufacturing, industrial, or other heavy industry experience preferred.<\/p>","post_title":"Senior Accountant","post_link":"https:\/\/turnerstaffing.com\/position\/senior-accountant\/","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>Responsibilities<\/p>\n<p>\uf0b7 Coordinate and support the company's accounting and financial reporting functions,<\/p>\n<p>including cost accounting activities.<\/p>\n<p>\uf0b7 Maintain accounting records, general ledger accounts, and supporting documentation in<\/p>\n<p>accordance with IFRS, GAAP, and Company policies.<\/p>\n<p>\uf0b7 Assist with month-end, quarter-end, and year-end close processes, including journal<\/p>\n<p>entries, accruals, reconciliations, and financial reporting.<\/p>\n<p>\uf0b7 Prepare and analyze account reconciliations, investigate variances, and proactively<\/p>\n<p>resolve discrepancies.<\/p>\n<p>\uf0b7 Assist in the preparation of monthly financial statements and management reporting<\/p>\n<p>packages.<\/p>\n<p>\uf0b7 Support internal and external audits by coordinating schedules, documentation, and<\/p>\n<p>audit requests.<\/p>\n<p>\uf0b7 Assist with compliance related to federal, state, local, payroll, sales\/use, and other<\/p>\n<p>applicable taxes.<\/p>\n<p>\uf0b7 Perform cost accounting activities, including cost variance analysis, inventory valuation,<\/p>\n<p>and operational cost reporting.<\/p>\n<p>\uf0b7 Support material inventory controls, including validation of inventory transactions and<\/p>\n<p>periodic inventory counts.<\/p>\n<p>\uf0b7 Review purchasing and procurement transactions to ensure proper accounting<\/p>\n<p>treatment and compliance with Company policies.<\/p>\n<p>JOB DESCRIPTION<\/p>\n<p>\uf0b7 Maintain fixed asset records, including capital project tracking (CIP), depreciation, asset<\/p>\n<p>additions, disposals, and annual physical inventories.<\/p>\n<p>\uf0b7 Assist with internal control compliance, documentation, and continuous improvement<\/p>\n<p>initiatives.<\/p>\n<p>\uf0b7 Support accounts payable, accounts receivable, payroll, treasury, and other accounting<\/p>\n<p>functions as needed to ensure business continuity and operational success.<\/p>\n<p>\uf0b7 Prepare and distribute financial reports, schedules, and supporting analyses for<\/p>\n<p>management and corporate reporting.<\/p>\n<p>\uf0b7 Build strong working relationships across operations, maintenance, supply chain,<\/p>\n<p>technical services, and corporate finance teams.<\/p>\n<p>\uf0b7 Contribute ideas and actions toward process improvements that enhance efficiency,<\/p>\n<p>accuracy, and financial controls.<\/p>\n<p>\uf0b7 Participate in special projects and other duties as assigned.<\/p>\n<p>The above responsibilities are representative and may not include all assigned duties.<\/p>\n<p>Education and Experience<\/p>\n<p>\u2022 Bachelor\u2019s degree in accounting or related field required.<\/p>\n<p>\u2022 5+ years of progressive accounting experience required.<\/p>\n<p>\u2022 CPA, CMA, or CPA-track strongly preferred.<\/p>\n<p>\u2022 Experience with financial reporting, month-end close, account reconciliations, and<\/p>\n<p>internal controls required.<\/p>\n<p>\u2022 Experience with cost accounting, inventory accounting, fixed assets, or capital project<\/p>\n<p>accounting preferred.<\/p>\n<p>\u2022 Mining, manufacturing, industrial, or other heavy industry experience preferred.<\/p>","%category%":"Finance","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/a39324e0a8b3-senior-accountant","%breezy_id%":"a39324e0a8b3","%breezy_friendly_id%":"a39324e0a8b3-senior-accountant","%breezy_created_date%":"2026-07-09T14:29:29.115Z","%breezy_updated_date%":"2026-07-09T14:30:11.211Z","%_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%":"633"}},"id":3903,"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    Job Overview: As a Haul Truck Driver, you will play a crucial role in the transportation of materials within the&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":"Job Overview: As a Haul Truck Driver, you will play a crucial role in the transportation of materials within the&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-driver\/","zoom":19,"extra_fields":{"post_excerpt":"Job Overview: As a Haul Truck Driver, you will play a crucial role in the transportation of materials within the&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Job Overview: 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsibilities:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safe Operation of Haul Trucks:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Operate haul trucks to transport materials within the mining site.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Adhere to all safety protocols and guidelines to ensure a safe working environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Material Transportation:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Load, transport, and unload materials according to project specifications and production schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Communicate effectively with equipment operators and supervisors to coordinate material movement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Equipment Maintenance:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Conduct pre-shift inspections on haul trucks and report any issues to the maintenance team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Ensure routine maintenance tasks are performed to keep equipment in optimal condition.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety Compliance:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Follow safety procedures and guidelines to prevent accidents and injuries.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Participate in safety meetings and training sessions as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Record Keeping:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Maintain accurate records of material transported, distances covered, and fuel consumption.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px 0px 0px 2em\">Report any incidents or accidents promptly.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Requirements:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Proven experience as a Articulating Haul Truck Driver in a mining or heavy equipment environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA certificate preferred.&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Knowledge of safe haul truck operation practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work in a physically demanding and outdoor environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong communication skills and the ability to work as part of a team.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Benefits:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Competitive salary<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Health, dental, and vision insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Retirement savings plan<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%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%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Job Overview: 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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safe Operation of Haul Trucks:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Operate haul trucks to transport materials within the mining site.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Adhere to all safety protocols and guidelines to ensure a safe working environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Material Transportation:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Load, transport, and unload materials according to project specifications and production schedules.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Communicate effectively with equipment operators and supervisors to coordinate material movement.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Equipment Maintenance:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Conduct pre-shift inspections on haul trucks and report any issues to the maintenance team.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Ensure routine maintenance tasks are performed to keep equipment in optimal condition.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety Compliance:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Follow safety procedures and guidelines to prevent accidents and injuries.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Participate in safety meetings and training sessions as required.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Record Keeping:<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Maintain accurate records of material transported, distances covered, and fuel consumption.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px 0px 0px 2em;\">Report any incidents or accidents promptly.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Requirements:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Proven experience as a Articulating Haul Truck Driver in a mining or heavy equipment environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA certificate preferred.&nbsp;<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Knowledge of safe haul truck operation practices.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work in a physically demanding and outdoor environment.<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong communication skills and the ability to work as part of a team.<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Benefits:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Competitive salary<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Health, dental, and vision insurance<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Retirement savings plan<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/b468db29ec99-haul-truck-driver","%breezy_id%":"b468db29ec99","%breezy_friendly_id%":"b468db29ec99-haul-truck-driver","%breezy_created_date%":"2026-07-10T12:46:41.547Z","%breezy_updated_date%":"2026-07-10T12:46:43.803Z","%_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","%rank_math_analytic_object_id%":"634"}},"id":3904,"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    General Laborer Responsibilities:&nbsp; Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP installation, demo, install and&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":"General Laborer Responsibilities:&nbsp; Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP installation, demo, install and&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\/","zoom":19,"extra_fields":{"post_excerpt":"General Laborer Responsibilities:&nbsp; Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP installation, demo, install and&hellip;","post_content":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><u>General Laborer<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Responsibilities:&nbsp;<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">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>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">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>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Requirements:<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong work ethic<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Willingness to learn<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to be flexible and to adapt<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with heavy equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred to have MSHA training<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"General Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%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%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><u>General Laborer<\/u><\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Responsibilities:&nbsp;<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">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>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">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>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Requirements:<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Safety oriented, awareness of everyone and everything that is around you<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong work ethic<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Willingness to learn<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to be flexible and to adapt<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with heavy equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred to have MSHA training<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/4a5ce75d9994-general-laborer","%breezy_id%":"4a5ce75d9994","%breezy_friendly_id%":"4a5ce75d9994-general-laborer","%breezy_created_date%":"2026-07-10T12:51:37.595Z","%breezy_updated_date%":"2026-07-10T12:51:41.379Z","%_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","%rank_math_analytic_object_id%":"635"}},"id":3905,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician\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\/\" name=\"Industrial Electrician\" 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\/","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":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Job Summary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Install, inspect, maintain, and repair industrial electrical systems, including power distribution, motors, MCCs, VFDs, PLCs, lighting systems, and instrumentation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Troubleshoot electrical faults on mining equipment such as conveyors, crushers, pumps, drills, and processing plant equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Perform preventative and corrective maintenance to minimize downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Read and interpret electrical schematics, blueprints, and technical manuals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Test electrical systems using appropriate meters and diagnostic tools<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ensure all work complies with MSHA regulations, NEC standards, and site-specific safety policies<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Lockout\/tagout equipment and follow all safety and environmental procedures<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Communicate effectively with maintenance, operations, and supervision regarding equipment status and repairs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Maintain accurate maintenance records and documentation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Participate in safety meetings, inspections, and audits as required<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Journeyman Electrician certification or equivalent industrial electrical experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience as an industrial electrician, preferably in a mining or heavy industrial environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Strong knowledge of AC\/DC systems, motor controls, and industrial electrical troubleshooting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Ability to work independently in a fast-paced, production-driven environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Tools &amp; Equipment Requirement<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Employees must furnish their own basic electrical hand tools and meters, including but not limited to multimeters, clamp meters, and standard electrician tools<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Physical &amp; Work Environment<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">MSHA certification<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Experience with PLC troubleshooting and VFDs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\">Mining or aggregate industry experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;margin:0px\"><br><\/p>","post_title":"Industrial Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%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%":"<p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Job Summary<\/p><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">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><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Key Responsibilities<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Install, inspect, maintain, and repair industrial electrical systems, including power distribution, motors, MCCs, VFDs, PLCs, lighting systems, and instrumentation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Troubleshoot electrical faults on mining equipment such as conveyors, crushers, pumps, drills, and processing plant equipment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Perform preventative and corrective maintenance to minimize downtime<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Read and interpret electrical schematics, blueprints, and technical manuals<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Test electrical systems using appropriate meters and diagnostic tools<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ensure all work complies with MSHA regulations, NEC standards, and site-specific safety policies<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Lockout\/tagout equipment and follow all safety and environmental procedures<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Communicate effectively with maintenance, operations, and supervision regarding equipment status and repairs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Maintain accurate maintenance records and documentation<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Participate in safety meetings, inspections, and audits as required<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Required Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Journeyman Electrician certification or equivalent industrial electrical experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience as an industrial electrician, preferably in a mining or heavy industrial environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Strong knowledge of AC\/DC systems, motor controls, and industrial electrical troubleshooting<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Ability to work independently in a fast-paced, production-driven environment<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Tools &amp; Equipment Requirement<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Employees must furnish their own basic electrical hand tools and meters, including but not limited to multimeters, clamp meters, and standard electrician tools<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Physical &amp; Work Environment<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Preferred Qualifications<\/p><ul style=\"margin:0px;padding-left:40px;\">\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">MSHA certification<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Experience with PLC troubleshooting and VFDs<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\">Mining or aggregate industry experience<\/li>\n<li style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/li>\n<\/ul><p style=\"line-height:1.5;font-family:Arial;font-size:16px;color:rgb(0, 0, 0);margin:0px;\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/e0951708bf1d-industrial-electrician","%breezy_id%":"e0951708bf1d","%breezy_friendly_id%":"e0951708bf1d-industrial-electrician","%breezy_created_date%":"2026-07-10T12:53:51.348Z","%breezy_updated_date%":"2026-07-10T12:53:54.414Z","%_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","%rank_math_analytic_object_id%":"636"}},"id":3906,"infowindow_disable":false},{"source":"post","title":"Chief Surveyor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Chief Surveyor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Opportunity The Chief Surveyor is responsible for the overall management, planning, execution, and quality control of all mine surveying&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/chief-surveyor\/\" name=\"Chief Surveyor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Opportunity The Chief Surveyor is responsible for the overall management, planning, execution, and quality control of all mine surveying&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\/chief-surveyor\/","zoom":19,"extra_fields":{"post_excerpt":"The Opportunity The Chief Surveyor is responsible for the overall management, planning, execution, and quality control of all mine surveying&hellip;","post_content":"<p>The Opportunity<\/p>\n<p>The Chief Surveyor is responsible for the overall management, planning, execution, and<\/p>\n<p>quality control of all mine surveying activities. This role ensures accurate spatial data<\/p>\n<p>collection, mine design compliance, legal boundary control, volumetric calculations, and<\/p>\n<p>support for safe and efficient mining operations. The Chief Surveyor leads the survey<\/p>\n<p>team, oversees survey technologies and systems, and ensures compliance with<\/p>\n<p>regulatory, operational, and company standards.<\/p>\n<p>Responsibilities<\/p>\n<p>\uf0b7 Lead, supervise, mentor, and develop mine survey personnel.<\/p>\n<p>\uf0b7 Establish departmental goals, work plans, and performance standards.<\/p>\n<p>\uf0b7 Coordinate survey activities with mine planning, geology, engineering,<\/p>\n<p>operations, and environmental teams.<\/p>\n<p>\uf0b7 Manage contractor survey services when required.<\/p>\n<p>\uf0b7 Develop and maintain survey procedures, standards, and best practices.<\/p>\n<p>\uf0b7 Plan and oversee all surface and underground survey activities.<\/p>\n<p>\uf0b7 Ensure accurate positioning and control networks are established and<\/p>\n<p>maintained.<\/p>\n<p>\uf0b7 Verify mine development and production activities conform to approved mine<\/p>\n<p>plans and designs.<\/p>\n<p>\uf0b7 Conduct and review topographic, boundary, construction, and as-built surveys.<\/p>\n<p>\uf0b7 Monitor mining progress and provide accurate survey information to operational<\/p>\n<p>teams.<\/p>\n<p>\uf0b7 Maintain survey databases, drawings, plans, and spatial records.<\/p>\n<p>\uf0b7 Produce accurate maps, plans, sections, and 3D models.<\/p>\n<p>\uf0b7 Prepare volumetric calculations for ore extraction, stockpiles, waste dumps, and<\/p>\n<p>tailings facilities.<\/p>\n<p><\/p>\n<p>JOB DESCRIPTION<\/p>\n<p><\/p>\n<p>\uf0b7 Generate periodic reports for management, regulatory agencies, and technical<\/p>\n<p>teams.<\/p>\n<p>\uf0b7 Ensure data integrity and proper document control.<\/p>\n<p>\uf0b7 Manage the use of GNSS\/GPS equipment, total stations, laser scanners,<\/p>\n<p>drones\/UAVs, and other survey technologies.<\/p>\n<p>\uf0b7 Oversee mine surveying software and GIS systems.<\/p>\n<p>\uf0b7 Evaluate and implement new technologies to improve efficiency, safety, and<\/p>\n<p>accuracy.<\/p>\n<p>\uf0b7 Ensure proper calibration and maintenance of survey equipment.<\/p>\n<p>\uf0b7 Ensure all survey activities comply with applicable mining laws, regulations,<\/p>\n<p>permits, and company policies.<\/p>\n<p>\uf0b7 Maintain legal mine boundaries and property records.<\/p>\n<p>\uf0b7 Support permitting, land management, and regulatory reporting requirements.<\/p>\n<p>\uf0b7 Provide survey documentation required for audits and inspections.<\/p>\n<p>The above responsibilities are representative and may not include all assigned duties.<\/p>\n<p>Education and Experience<\/p>\n<p>\uf0b7 Bachelor's Degree in Surveying, Geomatics, Geospatial Science, Mining<\/p>\n<p>Engineering, Civil Engineering, or a related discipline.<\/p>\n<p>\uf0b7 10+ years of progressive surveying experience within mining operations.<\/p>\n<p>\uf0b7 5+ years in a supervisory or leadership role managing survey teams.<\/p>\n<p>\uf0b7 Experience in both surface and underground mining environments.<\/p>\n<p>\uf0b7 Experience with large-scale open pit, underground, or combined mining<\/p>\n<p>operations.<\/p>\n<p>\uf0b7 Demonstrated experience establishing and maintaining mine control networks.<\/p>\n<p>\uf0b7 Experience supporting mine planning, resource modeling, and production<\/p>\n<p>reconciliation.<\/p>\n<p>\uf0b7 Proven experience managing survey databases and spatial information systems.<\/p>\n<p>\uf0b7 Required certifications and licenses include but are not limited to:<\/p>\n<p>o Professional Land Surveyor (PLS), Professional Surveyor (PS), Registered<\/p>\n<p>Professional Land Surveyor (RPLS), or equivalent registration as required<\/p>\n<p>by applicable jurisdiction.<\/p>\n<p>o Valid driver's license.<\/p>\n<p>o Mine site safety training required by local regulations and company<\/p>\n<p>standards.<\/p>\n<p><\/p>\n<p>\uf0b7 Advanced proficiency with mine surveying software (e.g., Deswik, Vulcan,<\/p>\n<p>MineSight, Surpac).<\/p>\n<p>\uf0b7 Experience with GIS platforms such as ArcGIS.<\/p>\n<p>\uf0b7 Strong knowledge of GNSS\/GPS systems, total stations, laser scanning, and<\/p>\n<p>photogrammetry.<\/p>\n<p>\uf0b7 Experience with UAV-based surveying and LiDAR technologies.<\/p>\n<p>\uf0b7 Proficiency in CAD and 3D modeling software.<\/p>\n<p><br>\n\n<\/p>","post_title":"Chief Surveyor","post_link":"https:\/\/turnerstaffing.com\/position\/chief-surveyor\/","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>The Opportunity<\/p>\n<p>The Chief Surveyor is responsible for the overall management, planning, execution, and<\/p>\n<p>quality control of all mine surveying activities. This role ensures accurate spatial data<\/p>\n<p>collection, mine design compliance, legal boundary control, volumetric calculations, and<\/p>\n<p>support for safe and efficient mining operations. The Chief Surveyor leads the survey<\/p>\n<p>team, oversees survey technologies and systems, and ensures compliance with<\/p>\n<p>regulatory, operational, and company standards.<\/p>\n<p>Responsibilities<\/p>\n<p>\uf0b7 Lead, supervise, mentor, and develop mine survey personnel.<\/p>\n<p>\uf0b7 Establish departmental goals, work plans, and performance standards.<\/p>\n<p>\uf0b7 Coordinate survey activities with mine planning, geology, engineering,<\/p>\n<p>operations, and environmental teams.<\/p>\n<p>\uf0b7 Manage contractor survey services when required.<\/p>\n<p>\uf0b7 Develop and maintain survey procedures, standards, and best practices.<\/p>\n<p>\uf0b7 Plan and oversee all surface and underground survey activities.<\/p>\n<p>\uf0b7 Ensure accurate positioning and control networks are established and<\/p>\n<p>maintained.<\/p>\n<p>\uf0b7 Verify mine development and production activities conform to approved mine<\/p>\n<p>plans and designs.<\/p>\n<p>\uf0b7 Conduct and review topographic, boundary, construction, and as-built surveys.<\/p>\n<p>\uf0b7 Monitor mining progress and provide accurate survey information to operational<\/p>\n<p>teams.<\/p>\n<p>\uf0b7 Maintain survey databases, drawings, plans, and spatial records.<\/p>\n<p>\uf0b7 Produce accurate maps, plans, sections, and 3D models.<\/p>\n<p>\uf0b7 Prepare volumetric calculations for ore extraction, stockpiles, waste dumps, and<\/p>\n<p>tailings facilities.<\/p>\n<p><\/p>\n<p>JOB DESCRIPTION<\/p>\n<p><\/p>\n<p>\uf0b7 Generate periodic reports for management, regulatory agencies, and technical<\/p>\n<p>teams.<\/p>\n<p>\uf0b7 Ensure data integrity and proper document control.<\/p>\n<p>\uf0b7 Manage the use of GNSS\/GPS equipment, total stations, laser scanners,<\/p>\n<p>drones\/UAVs, and other survey technologies.<\/p>\n<p>\uf0b7 Oversee mine surveying software and GIS systems.<\/p>\n<p>\uf0b7 Evaluate and implement new technologies to improve efficiency, safety, and<\/p>\n<p>accuracy.<\/p>\n<p>\uf0b7 Ensure proper calibration and maintenance of survey equipment.<\/p>\n<p>\uf0b7 Ensure all survey activities comply with applicable mining laws, regulations,<\/p>\n<p>permits, and company policies.<\/p>\n<p>\uf0b7 Maintain legal mine boundaries and property records.<\/p>\n<p>\uf0b7 Support permitting, land management, and regulatory reporting requirements.<\/p>\n<p>\uf0b7 Provide survey documentation required for audits and inspections.<\/p>\n<p>The above responsibilities are representative and may not include all assigned duties.<\/p>\n<p>Education and Experience<\/p>\n<p>\uf0b7 Bachelor's Degree in Surveying, Geomatics, Geospatial Science, Mining<\/p>\n<p>Engineering, Civil Engineering, or a related discipline.<\/p>\n<p>\uf0b7 10+ years of progressive surveying experience within mining operations.<\/p>\n<p>\uf0b7 5+ years in a supervisory or leadership role managing survey teams.<\/p>\n<p>\uf0b7 Experience in both surface and underground mining environments.<\/p>\n<p>\uf0b7 Experience with large-scale open pit, underground, or combined mining<\/p>\n<p>operations.<\/p>\n<p>\uf0b7 Demonstrated experience establishing and maintaining mine control networks.<\/p>\n<p>\uf0b7 Experience supporting mine planning, resource modeling, and production<\/p>\n<p>reconciliation.<\/p>\n<p>\uf0b7 Proven experience managing survey databases and spatial information systems.<\/p>\n<p>\uf0b7 Required certifications and licenses include but are not limited to:<\/p>\n<p>o Professional Land Surveyor (PLS), Professional Surveyor (PS), Registered<\/p>\n<p>Professional Land Surveyor (RPLS), or equivalent registration as required<\/p>\n<p>by applicable jurisdiction.<\/p>\n<p>o Valid driver's license.<\/p>\n<p>o Mine site safety training required by local regulations and company<\/p>\n<p>standards.<\/p>\n<p><\/p>\n<p>\uf0b7 Advanced proficiency with mine surveying software (e.g., Deswik, Vulcan,<\/p>\n<p>MineSight, Surpac).<\/p>\n<p>\uf0b7 Experience with GIS platforms such as ArcGIS.<\/p>\n<p>\uf0b7 Strong knowledge of GNSS\/GPS systems, total stations, laser scanning, and<\/p>\n<p>photogrammetry.<\/p>\n<p>\uf0b7 Experience with UAV-based surveying and LiDAR technologies.<\/p>\n<p>\uf0b7 Proficiency in CAD and 3D modeling software.<\/p>\n<p><br>\n\n<\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/85ea4a387882-chief-surveyor","%breezy_id%":"85ea4a387882","%breezy_friendly_id%":"85ea4a387882-chief-surveyor","%breezy_created_date%":"2026-07-06T14:50:18.645Z","%breezy_updated_date%":"2026-07-06T14:50:54.541Z","%_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%":"626"}},"id":3896,"infowindow_disable":false},{"source":"post","title":"Project Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Lead Summary Turner Staffing Group is hiring for a Project Lead for our client to interface with customers, engineers,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-lead\/\" name=\"Project Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Lead Summary Turner Staffing Group is hiring for a Project Lead for our client to interface with customers, engineers,&hellip;","address":"Tempe, AZ, USA","location":{"lat":"33.4255104","city":"Tempe","state":"AZ","country":"United States","lng":"-111.9400054","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-lead\/","zoom":19,"extra_fields":{"post_excerpt":"Project Lead Summary Turner Staffing Group is hiring for a Project Lead for our client to interface with customers, engineers,&hellip;","post_content":"<p><strong>Project Lead<\/strong><\/p>\n<p><strong>Summary<\/strong><\/p>\n<p><strong>Turner Staffing Group is hiring for a Project Lead for our client<\/strong> to interface with customers, engineers, outside agencies, supervisors, and managers regarding electric distribution and transmission services. This role evaluates, analyzes, and implements productivity tools, including hardware, software, and training. The Project Lead develops and delivers technical instruction and production support to improve automation efforts and overall performance, reviews designs for completeness, accuracy, and quality, prepares cost estimates, performs project management functions on complex projects, and assists with system development and enhancements.<\/p>\n<p><strong>What You'll Do<\/strong><\/p>\n<ul>\n <li>Report directly to the      Distribution Improvements (DI) Senior Design Manager and support all three      DI Design groups.<\/li>\n <li>Support design functions across      all Distribution Improvements Design groups, including Cable Replacement,      System Improvements, and Customer Improvements.<\/li>\n <li>Support DI Design and Analysts in      developing improved estimating processes.<\/li>\n <li>Review projects for design      standards, drafting standards, and CUE compliance, and identify training      opportunities based on recurring inconsistencies and errors.<\/li>\n <li>Coordinate with other DI Project      Leads to ensure consistency in design standards and resolve common design      issues.<\/li>\n <li>Provide coverage for meetings      with municipalities and customers when primary Project Leads are      unavailable.<\/li>\n <li>Meet with stakeholders to      identify best practices for streamlining the permitting process and      improving project efficiency.<\/li>\n <li>Develop training materials and      facilitate onboarding for new employees while providing ongoing training      for existing staff.<\/li>\n <li>Participate in the CAD Governance      Committee.<\/li>\n <li>Lead CAD efforts for municipal      projects, including referencing customer files into utility survey base      files.<\/li>\n <li>Coordinate with the survey team      to verify that project submittals and requests are complete and accurate      so work can proceed efficiently.<\/li>\n <li>Attend pre-construction meetings      and coordinate with Construction Consultants to ensure design accuracy and      constructability.<\/li>\n <li>Serve as the primary point of      contact for DI Design to ensure external design details remain current and      up to date.<\/li>\n<\/ul>","post_title":"Project Lead","post_link":"https:\/\/turnerstaffing.com\/position\/project-lead\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Tempe","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tempe, AZ","%education%":"","%department%":"TSG","%description%":"<p><strong>Project Lead<\/strong><\/p>\n<p><strong>Summary<\/strong><\/p>\n<p><strong>Turner Staffing Group is hiring for a Project Lead for our client<\/strong> to interface with customers, engineers, outside agencies, supervisors, and managers regarding electric distribution and transmission services. This role evaluates, analyzes, and implements productivity tools, including hardware, software, and training. The Project Lead develops and delivers technical instruction and production support to improve automation efforts and overall performance, reviews designs for completeness, accuracy, and quality, prepares cost estimates, performs project management functions on complex projects, and assists with system development and enhancements.<\/p>\n<p><strong>What You'll Do<\/strong><\/p>\n<ul>\n <li>Report directly to the      Distribution Improvements (DI) Senior Design Manager and support all three      DI Design groups.<\/li>\n <li>Support design functions across      all Distribution Improvements Design groups, including Cable Replacement,      System Improvements, and Customer Improvements.<\/li>\n <li>Support DI Design and Analysts in      developing improved estimating processes.<\/li>\n <li>Review projects for design      standards, drafting standards, and CUE compliance, and identify training      opportunities based on recurring inconsistencies and errors.<\/li>\n <li>Coordinate with other DI Project      Leads to ensure consistency in design standards and resolve common design      issues.<\/li>\n <li>Provide coverage for meetings      with municipalities and customers when primary Project Leads are      unavailable.<\/li>\n <li>Meet with stakeholders to      identify best practices for streamlining the permitting process and      improving project efficiency.<\/li>\n <li>Develop training materials and      facilitate onboarding for new employees while providing ongoing training      for existing staff.<\/li>\n <li>Participate in the CAD Governance      Committee.<\/li>\n <li>Lead CAD efforts for municipal      projects, including referencing customer files into utility survey base      files.<\/li>\n <li>Coordinate with the survey team      to verify that project submittals and requests are complete and accurate      so work can proceed efficiently.<\/li>\n <li>Attend pre-construction meetings      and coordinate with Construction Consultants to ensure design accuracy and      constructability.<\/li>\n <li>Serve as the primary point of      contact for DI Design to ensure external design details remain current and      up to date.<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/bfd2d6a3c175-project-lead","%breezy_id%":"bfd2d6a3c175","%breezy_friendly_id%":"bfd2d6a3c175-project-lead","%breezy_created_date%":"2026-07-08T17:30:08.637Z","%breezy_updated_date%":"2026-09-08T22:30:58.940Z","%_wpgmp_location_city%":"Tempe","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tempe, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4255104","%_wpgmp_metabox_longitude%":"-111.9400054","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"628"}},"id":3898,"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\/\" 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\/","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\/","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\/80f553ba7c99-excavator-operator","%breezy_id%":"80f553ba7c99","%breezy_friendly_id%":"80f553ba7c99-excavator-operator","%breezy_created_date%":"2026-07-08T17:42:31.427Z","%breezy_updated_date%":"2026-07-08T17:42:52.479Z","%_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","%rank_math_analytic_object_id%":"629"}},"id":3899,"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\/\" 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\/","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\/","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\/940cde08d0c4-general-laborer-mining","%breezy_id%":"940cde08d0c4","%breezy_friendly_id%":"940cde08d0c4-general-laborer-mining","%breezy_created_date%":"2026-07-08T17:43:09.170Z","%breezy_updated_date%":"2026-07-10T12:36:44.066Z","%_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","%rank_math_analytic_object_id%":"630"}},"id":3900,"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":"Duckwater, NV, USA","location":{"lat":"38.9317577","city":"Duckwater","state":"NV","country":"United States","lng":"-115.7147132","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%":"Duckwater","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Duckwater, 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\/5bb1b921d34e-haul-truck-operator-traveling","%breezy_id%":"5bb1b921d34e","%breezy_friendly_id%":"5bb1b921d34e-haul-truck-operator-traveling","%breezy_created_date%":"2026-04-24T14:57:53.266Z","%breezy_updated_date%":"2026-07-08T13:28:21.059Z","%_wpgmp_location_city%":"Duckwater","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Duckwater, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9317577","%_wpgmp_metabox_longitude%":"-115.7147132","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"606"}},"id":3894,"infowindow_disable":false},{"source":"post","title":"Travelling QC Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Travelling QC Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Traveling Quality Control Technician Turner Staffing Group Turner Staffing Group is seeking a Traveling Quality Control Technician Specialist to support&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/travelling-qc-technician\/\" name=\"Travelling QC Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Traveling Quality Control Technician Turner Staffing Group Turner Staffing Group is seeking a Traveling Quality Control Technician Specialist to support&hellip;","address":"Anaheim, CA, USA","location":{"lat":"33.8365932","city":"Anaheim","state":"CA","country":"United States","lng":"-117.9143012","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/travelling-qc-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Traveling Quality Control Technician Turner Staffing Group Turner Staffing Group is seeking a Traveling Quality Control Technician Specialist to support&hellip;","post_content":"<p><strong>Traveling Quality Control Technician <\/strong><\/p>\n<p><strong>Turner Staffing Group<\/strong><\/p>\n<p>Turner Staffing Group is seeking a Traveling Quality Control Technician Specialist to support field operations across multiple project sites. This role partners closely with Superintendents and Project Management teams to ensure all work is completed safely, efficiently, and in compliance with OSHA, MSHA, and project-specific quality standards.<\/p>\n<p>The ideal candidate will bring strong geomembrane installation experience, safety leadership, quality control expertise, and a commitment to maintaining exceptional standards in both field operations and customer service.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Safety Responsibilities<\/strong><\/p>\n<ul>\n <li>Promote and enforce company      safety standards across all job sites. <\/li>\n <li>Conduct field safety audits,      inspections, and employee training programs. <\/li>\n <li>Provide OSHA and MSHA compliance      support and documentation. <\/li>\n <li>Identify hazards, unsafe work      conditions, and opportunities for safety improvement. <\/li>\n <li>Maintain and manage near-miss      reporting and corrective action processes. <\/li>\n <li>Collaborate with Superintendents      and field leadership to address safety concerns and implement corrective      actions. <\/li>\n <li>Immediately report imminent      dangers, safety violations, or unsafe practices to management. <\/li>\n <li>Support efforts to minimize      regulatory citations through proactive compliance and training. <\/li>\n <li>Assist with additional      safety-related duties as assigned. <\/li>\n<\/ul>\n<p><strong>Quality Control Responsibilities<\/strong><\/p>\n<ul>\n <li>Implement and maintain quality      control standards for geomembrane liner system installations. <\/li>\n <li>Conduct field QC audits and      provide training to QC technicians. <\/li>\n <li>Lead and participate in weekly QC      meetings. <\/li>\n <li>Review QC reporting, project      documentation, and as-built drawings for accuracy and completeness. <\/li>\n <li>Ensure all installations meet      project specifications and ASTM testing standards. <\/li>\n <li>Report any deviations from      project plans, specifications, or QA\/QC programs immediately. <\/li>\n <li>Coordinate with Project      Management teams regarding weekly operational reporting requirements. <\/li>\n <li>Ensure all required documentation      is submitted accurately and on time. <\/li>\n <li>Perform additional quality      control duties as assigned. <\/li>\n<\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<p>Qualified candidates should meet the following requirements:<\/p>\n<ul>\n <li>Proficiency with Microsoft Office      and general computer applications. <\/li>\n <li>Ability to read, write, and      communicate effectively in both English and Spanish. <\/li>\n <li>Minimum experience meeting or      exceeding IAGI qualifications (3 years \/ 3,000,000 SF of direct      participation). <\/li>\n <li>Strong understanding of      geomembrane lining systems and installation methods. <\/li>\n <li>Demonstrated ability to perform      field seaming that meets project specifications. <\/li>\n <li>Knowledge of ASTM testing      procedures and QC standards. <\/li>\n <li>Ability to troubleshoot and      maintain seaming equipment. <\/li>\n <li>Understanding of construction      safety practices while working around heavy equipment. <\/li>\n <li>Ability to work outdoors in      varying weather and site conditions. <\/li>\n <li>Must pass regular drug and      alcohol screenings. <\/li>\n <li>Reliable transportation and      dependable attendance required. <\/li>\n <li>Willingness and ability to travel      extensively, including overnight stays. <\/li>\n <li>Ability to safely perform      physically demanding work including climbing, bending, kneeling, lifting,      and working at heights or on uneven terrain. <\/li>\n <li>Commitment to following all      company safety policies and procedures. <\/li>\n <li>Flexibility to work hours      necessary to support project demands. <\/li>\n<\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<p>This position is primarily based at active construction and industrial job sites and requires frequent travel. Candidates should be comfortable working in outdoor environments that may include heat, cold, wind, rain, snow, uneven terrain, elevated work areas, and work near water.<\/p>\n<p><strong>Why Join Turner Staffing Group?<\/strong><\/p>\n<p>At Turner Staffing Group, we connect skilled professionals with industry-leading opportunities in construction, mining, industrial, and energy sectors. We value safety, professionalism, teamwork, and career growth while supporting employees with meaningful long-term opportunities across the country.<\/p>","post_title":"Travelling QC Technician","post_link":"https:\/\/turnerstaffing.com\/position\/travelling-qc-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Anaheim","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Anaheim, CA","%education%":"","%department%":"TSG","%description%":"<p><strong>Traveling Quality Control Technician <\/strong><\/p>\n<p><strong>Turner Staffing Group<\/strong><\/p>\n<p>Turner Staffing Group is seeking a Traveling Quality Control Technician Specialist to support field operations across multiple project sites. This role partners closely with Superintendents and Project Management teams to ensure all work is completed safely, efficiently, and in compliance with OSHA, MSHA, and project-specific quality standards.<\/p>\n<p>The ideal candidate will bring strong geomembrane installation experience, safety leadership, quality control expertise, and a commitment to maintaining exceptional standards in both field operations and customer service.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Safety Responsibilities<\/strong><\/p>\n<ul>\n <li>Promote and enforce company      safety standards across all job sites. <\/li>\n <li>Conduct field safety audits,      inspections, and employee training programs. <\/li>\n <li>Provide OSHA and MSHA compliance      support and documentation. <\/li>\n <li>Identify hazards, unsafe work      conditions, and opportunities for safety improvement. <\/li>\n <li>Maintain and manage near-miss      reporting and corrective action processes. <\/li>\n <li>Collaborate with Superintendents      and field leadership to address safety concerns and implement corrective      actions. <\/li>\n <li>Immediately report imminent      dangers, safety violations, or unsafe practices to management. <\/li>\n <li>Support efforts to minimize      regulatory citations through proactive compliance and training. <\/li>\n <li>Assist with additional      safety-related duties as assigned. <\/li>\n<\/ul>\n<p><strong>Quality Control Responsibilities<\/strong><\/p>\n<ul>\n <li>Implement and maintain quality      control standards for geomembrane liner system installations. <\/li>\n <li>Conduct field QC audits and      provide training to QC technicians. <\/li>\n <li>Lead and participate in weekly QC      meetings. <\/li>\n <li>Review QC reporting, project      documentation, and as-built drawings for accuracy and completeness. <\/li>\n <li>Ensure all installations meet      project specifications and ASTM testing standards. <\/li>\n <li>Report any deviations from      project plans, specifications, or QA\/QC programs immediately. <\/li>\n <li>Coordinate with Project      Management teams regarding weekly operational reporting requirements. <\/li>\n <li>Ensure all required documentation      is submitted accurately and on time. <\/li>\n <li>Perform additional quality      control duties as assigned. <\/li>\n<\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<p>Qualified candidates should meet the following requirements:<\/p>\n<ul>\n <li>Proficiency with Microsoft Office      and general computer applications. <\/li>\n <li>Ability to read, write, and      communicate effectively in both English and Spanish. <\/li>\n <li>Minimum experience meeting or      exceeding IAGI qualifications (3 years \/ 3,000,000 SF of direct      participation). <\/li>\n <li>Strong understanding of      geomembrane lining systems and installation methods. <\/li>\n <li>Demonstrated ability to perform      field seaming that meets project specifications. <\/li>\n <li>Knowledge of ASTM testing      procedures and QC standards. <\/li>\n <li>Ability to troubleshoot and      maintain seaming equipment. <\/li>\n <li>Understanding of construction      safety practices while working around heavy equipment. <\/li>\n <li>Ability to work outdoors in      varying weather and site conditions. <\/li>\n <li>Must pass regular drug and      alcohol screenings. <\/li>\n <li>Reliable transportation and      dependable attendance required. <\/li>\n <li>Willingness and ability to travel      extensively, including overnight stays. <\/li>\n <li>Ability to safely perform      physically demanding work including climbing, bending, kneeling, lifting,      and working at heights or on uneven terrain. <\/li>\n <li>Commitment to following all      company safety policies and procedures. <\/li>\n <li>Flexibility to work hours      necessary to support project demands. <\/li>\n<\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<p>This position is primarily based at active construction and industrial job sites and requires frequent travel. Candidates should be comfortable working in outdoor environments that may include heat, cold, wind, rain, snow, uneven terrain, elevated work areas, and work near water.<\/p>\n<p><strong>Why Join Turner Staffing Group?<\/strong><\/p>\n<p>At Turner Staffing Group, we connect skilled professionals with industry-leading opportunities in construction, mining, industrial, and energy sectors. We value safety, professionalism, teamwork, and career growth while supporting employees with meaningful long-term opportunities across the country.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/ef274774fd61-travelling-qc-technician","%breezy_id%":"ef274774fd61","%breezy_friendly_id%":"ef274774fd61-travelling-qc-technician","%breezy_created_date%":"2026-05-20T20:25:22.587Z","%breezy_updated_date%":"2026-09-08T22:33:43.880Z","%_wpgmp_location_city%":"Anaheim","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Anaheim, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.8365932","%_wpgmp_metabox_longitude%":"-117.9143012","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"615"}},"id":3895,"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-4\/\" 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":"Salt Lake City, UT, USA","location":{"lat":"40.7605601","city":"Salt Lake City","state":"UT","country":"United States","lng":"-111.8881397","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-traveling-4\/","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-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Salt Lake City","%location_state_id%":"UT","%location_state_name%":"Utah","%location_city_state%":"Salt Lake City, UT","%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\/0314e4677ab7-general-laborer-mining--traveling","%breezy_id%":"0314e4677ab7","%breezy_friendly_id%":"0314e4677ab7-general-laborer-mining--traveling","%breezy_created_date%":"2026-04-15T17:41:04.960Z","%breezy_updated_date%":"2026-07-08T12:44:35.392Z","%_wpgmp_location_city%":"Salt Lake City","%_wpgmp_location_state%":"UT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Salt Lake City, UT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.7605601","%_wpgmp_metabox_longitude%":"-111.8881397","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"595"}},"id":3889,"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-5\/\" 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":"West Wendover, NV, USA","location":{"lat":"40.739097","city":"West Wendover","state":"NV","country":"United States","lng":"-114.073345","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-traveling-5\/","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-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"West Wendover","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"West Wendover, 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\/97c977123259-general-laborer-mining--traveling","%breezy_id%":"97c977123259","%breezy_friendly_id%":"97c977123259-general-laborer-mining--traveling","%breezy_created_date%":"2026-04-15T17:43:31.094Z","%breezy_updated_date%":"2026-07-08T13:19:03.839Z","%_wpgmp_location_city%":"West Wendover","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"West Wendover, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.739097","%_wpgmp_metabox_longitude%":"-114.073345","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"596"}},"id":3890,"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-6\/\" 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":"Duckwater, NV, USA","location":{"lat":"38.9317577","city":"Duckwater","state":"NV","country":"United States","lng":"-115.7147132","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-traveling-6\/","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-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Duckwater","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Duckwater, 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\/185bda662b4a-general-laborer-mining--traveling","%breezy_id%":"185bda662b4a","%breezy_friendly_id%":"185bda662b4a-general-laborer-mining--traveling","%breezy_created_date%":"2026-04-15T17:44:26.759Z","%breezy_updated_date%":"2026-07-08T12:45:57.848Z","%_wpgmp_location_city%":"Duckwater","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Duckwater, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9317577","%_wpgmp_metabox_longitude%":"-115.7147132","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"597"}},"id":3891,"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-8\/\" 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":"Duckwater, NV, USA","location":{"lat":"38.9317577","city":"Duckwater","state":"NV","country":"United States","lng":"-115.7147132","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-8\/","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-8\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Duckwater","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Duckwater, 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\/de9e9add02b9-heavy-equipment-operator-traveling","%breezy_id%":"de9e9add02b9","%breezy_friendly_id%":"de9e9add02b9-heavy-equipment-operator-traveling","%breezy_created_date%":"2026-04-15T18:01:06.394Z","%breezy_updated_date%":"2026-07-08T12:42:29.316Z","%_wpgmp_location_city%":"Duckwater","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Duckwater, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9317577","%_wpgmp_metabox_longitude%":"-115.7147132","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"598"}},"id":3892,"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-9\/\" 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":"West Wendover, NV, USA","location":{"lat":"40.739097","city":"West Wendover","state":"NV","country":"United States","lng":"-114.073345","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-9\/","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-9\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"West Wendover","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"West Wendover, 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\/90945eda5d16-heavy-equipment-operator-traveling","%breezy_id%":"90945eda5d16","%breezy_friendly_id%":"90945eda5d16-heavy-equipment-operator-traveling","%breezy_created_date%":"2026-04-15T19:51:46.719Z","%breezy_updated_date%":"2026-07-08T12:38:54.342Z","%_wpgmp_location_city%":"West Wendover","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"West Wendover, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.739097","%_wpgmp_metabox_longitude%":"-114.073345","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"599"}},"id":3893,"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-5\/\" 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":"Reno, NV, USA","location":{"lat":"39.529919","city":"Reno","state":"NV","country":"United States","lng":"-119.8142691","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-5\/","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-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Reno","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Reno, 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\/3fe4ceb4132e-heavy-equipment-operator-traveling","%breezy_id%":"3fe4ceb4132e","%breezy_friendly_id%":"3fe4ceb4132e-heavy-equipment-operator-traveling","%breezy_created_date%":"2026-04-15T12:52:39.199Z","%breezy_updated_date%":"2026-07-08T12:36:52.886Z","%_wpgmp_location_city%":"Reno","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Reno, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.529919","%_wpgmp_metabox_longitude%":"-119.8142691","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"590"}},"id":3884,"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-2\/\" 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":"Reno, NV, USA","location":{"lat":"39.529919","city":"Reno","state":"NV","country":"United States","lng":"-119.8142691","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-traveling-2\/","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-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Reno","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Reno, 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\/6357cf574eb0-general-laborer-mining--traveling","%breezy_id%":"6357cf574eb0","%breezy_friendly_id%":"6357cf574eb0-general-laborer-mining--traveling","%breezy_created_date%":"2026-04-15T12:53:15.575Z","%breezy_updated_date%":"2026-07-08T13:20:44.920Z","%_wpgmp_location_city%":"Reno","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Reno, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.529919","%_wpgmp_metabox_longitude%":"-119.8142691","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"591"}},"id":3885,"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-6\/\" 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":"Salt Lake City, UT, USA","location":{"lat":"40.7605601","city":"Salt Lake City","state":"UT","country":"United States","lng":"-111.8881397","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-6\/","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-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Salt Lake City","%location_state_id%":"UT","%location_state_name%":"Utah","%location_city_state%":"Salt Lake City, UT","%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\/55486bdd628f-heavy-equipment-operator-traveling","%breezy_id%":"55486bdd628f","%breezy_friendly_id%":"55486bdd628f-heavy-equipment-operator-traveling","%breezy_created_date%":"2026-04-15T16:12:01.035Z","%breezy_updated_date%":"2026-07-08T12:33:11.406Z","%_wpgmp_location_city%":"Salt Lake City","%_wpgmp_location_state%":"UT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Salt Lake City, UT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.7605601","%_wpgmp_metabox_longitude%":"-111.8881397","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"592"}},"id":3886,"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-7\/\" 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":"Flagstaff, AZ, USA","location":{"lat":"35.1982836","city":"Flagstaff","state":"AZ","country":"United States","lng":"-111.651302","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-traveling-7\/","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-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Flagstaff","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Flagstaff, AZ","%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\/d41d24983839-heavy-equipment-operator-traveling","%breezy_id%":"d41d24983839","%breezy_friendly_id%":"d41d24983839-heavy-equipment-operator-traveling","%breezy_created_date%":"2026-04-15T17:24:48.540Z","%breezy_updated_date%":"2026-07-08T12:40:38.258Z","%_wpgmp_location_city%":"Flagstaff","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Flagstaff, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1982836","%_wpgmp_metabox_longitude%":"-111.651302","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"593"}},"id":3887,"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-3\/\" 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":"Flagstaff, AZ, USA","location":{"lat":"35.1982836","city":"Flagstaff","state":"AZ","country":"United States","lng":"-111.651302","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-traveling-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 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-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Flagstaff","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Flagstaff, AZ","%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\/d78ca84a0083-general-laborer-mining--traveling","%breezy_id%":"d78ca84a0083","%breezy_friendly_id%":"d78ca84a0083-general-laborer-mining--traveling","%breezy_created_date%":"2026-04-15T17:39:23.502Z","%breezy_updated_date%":"2026-07-08T13:17:32.817Z","%_wpgmp_location_city%":"Flagstaff","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Flagstaff, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1982836","%_wpgmp_metabox_longitude%":"-111.651302","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"594"}},"id":3888,"infowindow_disable":false},{"source":"post","title":"Yard Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Yard Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You\u2019ll Be Doing Operate loader equipment safely to move, load, and organize materials Perform routine equipment inspections and basic&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/yard-loader-operator-2\/\" name=\"Yard Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You\u2019ll Be Doing Operate loader equipment safely to move, load, and organize materials Perform routine equipment inspections and basic&hellip;","address":"Skaneateles, NY, USA","location":{"lat":"42.947011","city":"Skaneateles","state":"NY","country":"United States","lng":"-76.4291017","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/yard-loader-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"What You\u2019ll Be Doing Operate loader equipment safely to move, load, and organize materials Perform routine equipment inspections and basic&hellip;","post_content":"<p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Operate loader equipment safely to move, load, and organize materials<\/li><li>Perform routine equipment inspections and basic maintenance<\/li><li>Manage stockpiles and support yard material flow<\/li><li>Follow all safety procedures and maintain a clean, organized work area<\/li><li>Communicate effectively with team members to coordinate daily tasks<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate heavy equipment safely and confidently<\/li><li>Strong awareness of safety practices and commitment to following procedures<\/li><li>Capability to identify equipment issues and report them promptly<\/li><li>Effective communication skills and ability to work independently or with a team<\/li><li>Reliability, attention to detail, and readiness to learn yard operations<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><br><\/p>","post_title":"Yard Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/yard-loader-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Skaneateles","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Skaneateles, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Operate loader equipment safely to move, load, and organize materials<\/li><li>Perform routine equipment inspections and basic maintenance<\/li><li>Manage stockpiles and support yard material flow<\/li><li>Follow all safety procedures and maintain a clean, organized work area<\/li><li>Communicate effectively with team members to coordinate daily tasks<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate heavy equipment safely and confidently<\/li><li>Strong awareness of safety practices and commitment to following procedures<\/li><li>Capability to identify equipment issues and report them promptly<\/li><li>Effective communication skills and ability to work independently or with a team<\/li><li>Reliability, attention to detail, and readiness to learn yard operations<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><br><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/2ebff5f73ae5-yard-loader-operator","%breezy_id%":"2ebff5f73ae5","%breezy_friendly_id%":"2ebff5f73ae5-yard-loader-operator","%breezy_created_date%":"2026-02-11T02:14:37.744Z","%breezy_updated_date%":"2026-08-14T00:00:09.044Z","%_wpgmp_location_city%":"Skaneateles","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Skaneateles, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.947011","%_wpgmp_metabox_longitude%":"-76.4291017","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"566"}},"id":3881,"infowindow_disable":false},{"source":"post","title":"Warehouse Associate","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Warehouse Associate\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Warehouse Clerk Job Type: Full Time and OT as needed per business needs Schedule: 8 hour 5 days&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/warehouse-associate\/\" name=\"Warehouse Associate\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Warehouse Clerk Job Type: Full Time and OT as needed per business needs Schedule: 8 hour 5 days&hellip;","address":"Kearny, AZ, USA","location":{"lat":"33.0613504","city":"Kearny","state":"AZ","country":"United States","lng":"-110.9066589","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/warehouse-associate\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Warehouse Clerk Job Type: Full Time and OT as needed per business needs Schedule: 8 hour 5 days&hellip;","post_content":"<h2>Job Title: Warehouse Clerk<\/h2>\n<p><strong>Job Type:<\/strong> Full Time and OT as needed per business needs<br>\n<strong>Schedule:<\/strong> 8 hour 5 days a week or 10 hour 4 days a week depending upon business needs<\/p>\n<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is currently seeking a reliable and detail-oriented <strong>Warehouse Clerk<\/strong> to support day-to-day warehouse operations for our client. This position plays a key role in maintaining inventory accuracy, supporting material handling processes, and ensuring a safe and organized work environment.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Process and resolve warehouse-related issues.<\/p>\n<\/li>\n<li>\n<p>Perform physical inventory counts and complete stock adjustments as needed.<\/p>\n<\/li>\n<li>\n<p>Identify, verify, and receive incoming materials accurately.<\/p>\n<\/li>\n<li>\n<p>Safely unload freight using a forklift.<\/p>\n<\/li>\n<li>\n<p>Identify part number corrections, updates, or additions in inventory systems.<\/p>\n<\/li>\n<li>\n<p>Assist team members with locating and identifying parts.<\/p>\n<\/li>\n<li>\n<p>Maintain clean, organized, and properly stocked warehouse shelves.<\/p>\n<\/li>\n<li>\n<p>Ensure warehouse areas, yards, and outbuildings remain neat and orderly.<\/p>\n<\/li>\n<\/ul>\n<h3>Required Skills &amp; Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum of <strong>1 year of warehouse experience<\/strong> (required).<\/p>\n<\/li>\n<li>\n<p>Ability to safely operate a forklift.<\/p>\n<\/li>\n<li>\n<p>Strong commitment to workplace health, safety, and environmental compliance.<\/p>\n<\/li>\n<li>\n<p>Proficiency in <strong>Microsoft Office<\/strong> and <strong>SAP<\/strong> systems.<\/p>\n<\/li>\n<li>\n<p>Excellent interpersonal and communication skills.<\/p>\n<\/li>\n<li>\n<p>Strong time management skills with the ability to prioritize tasks effectively.<\/p>\n<\/li>\n<li>\n<p>Ability to manage multiple responsibilities in a fast-paced environment.<\/p>\n<\/li>\n<\/ul>\n<h3>Why Work with Turner Staffing Group?<\/h3>\n<p>At Turner Staffing Group, we connect hardworking professionals with leading employers across the industry. We value safety, reliability, and dedication, and we are committed to supporting our employees every step of the way.<\/p>\n<p>If you are dependable, safety-focused, and ready to contribute to a dynamic warehouse team, we encourage you to apply today.<\/p>","post_title":"Warehouse Associate","post_link":"https:\/\/turnerstaffing.com\/position\/warehouse-associate\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kearny","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kearny, AZ","%education%":"","%department%":"TSG","%description%":"<h2>Job Title: Warehouse Clerk<\/h2>\n<p><strong>Job Type:<\/strong> Full Time and OT as needed per business needs<br>\n<strong>Schedule:<\/strong> 8 hour 5 days a week or 10 hour 4 days a week depending upon business needs<\/p>\n<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is currently seeking a reliable and detail-oriented <strong>Warehouse Clerk<\/strong> to support day-to-day warehouse operations for our client. This position plays a key role in maintaining inventory accuracy, supporting material handling processes, and ensuring a safe and organized work environment.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Process and resolve warehouse-related issues.<\/p>\n<\/li>\n<li>\n<p>Perform physical inventory counts and complete stock adjustments as needed.<\/p>\n<\/li>\n<li>\n<p>Identify, verify, and receive incoming materials accurately.<\/p>\n<\/li>\n<li>\n<p>Safely unload freight using a forklift.<\/p>\n<\/li>\n<li>\n<p>Identify part number corrections, updates, or additions in inventory systems.<\/p>\n<\/li>\n<li>\n<p>Assist team members with locating and identifying parts.<\/p>\n<\/li>\n<li>\n<p>Maintain clean, organized, and properly stocked warehouse shelves.<\/p>\n<\/li>\n<li>\n<p>Ensure warehouse areas, yards, and outbuildings remain neat and orderly.<\/p>\n<\/li>\n<\/ul>\n<h3>Required Skills &amp; Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum of <strong>1 year of warehouse experience<\/strong> (required).<\/p>\n<\/li>\n<li>\n<p>Ability to safely operate a forklift.<\/p>\n<\/li>\n<li>\n<p>Strong commitment to workplace health, safety, and environmental compliance.<\/p>\n<\/li>\n<li>\n<p>Proficiency in <strong>Microsoft Office<\/strong> and <strong>SAP<\/strong> systems.<\/p>\n<\/li>\n<li>\n<p>Excellent interpersonal and communication skills.<\/p>\n<\/li>\n<li>\n<p>Strong time management skills with the ability to prioritize tasks effectively.<\/p>\n<\/li>\n<li>\n<p>Ability to manage multiple responsibilities in a fast-paced environment.<\/p>\n<\/li>\n<\/ul>\n<h3>Why Work with Turner Staffing Group?<\/h3>\n<p>At Turner Staffing Group, we connect hardworking professionals with leading employers across the industry. We value safety, reliability, and dedication, and we are committed to supporting our employees every step of the way.<\/p>\n<p>If you are dependable, safety-focused, and ready to contribute to a dynamic warehouse team, we encourage you to apply today.<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/19404157fb4a-warehouse-associate","%breezy_id%":"19404157fb4a","%breezy_friendly_id%":"19404157fb4a-warehouse-associate","%breezy_created_date%":"2026-03-02T16:23:16.432Z","%breezy_updated_date%":"2026-09-08T22:28:48.427Z","%_wpgmp_location_city%":"Kearny","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kearny, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.0613504","%_wpgmp_metabox_longitude%":"-110.9066589","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"568"}},"id":3882,"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    Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&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":"Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;","address":"Lancaster, PA, USA","location":{"lat":"40.0403279","city":"Lancaster","state":"PA","country":"United States","lng":"-76.3041833","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pipe-layer\/","zoom":19,"extra_fields":{"post_excerpt":"Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;","post_content":"<p>Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers REAL growth?<\/p>\n<p>We\u2019ve been waiting for you!<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the way pipe work is conducted. 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 safety oriented, hard working individual 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>Laborer duties include pipe rehabilitation, 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><li>Willingness to learn operating equipment<\/li><li>Team Player with GREAT attitude!<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Driver's License<\/li><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Knowledge of DOT Regulations<\/li><li>Experience in heavy highway utility work&nbsp;<\/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><\/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%":"Lancaster","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Lancaster, PA","%education%":"Unspecified","%department%":"TSG","%description%":"<p>Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers REAL growth?<\/p>\n<p>We\u2019ve been waiting for you!<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the way pipe work is conducted. 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 safety oriented, hard working individual 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>Laborer duties include pipe rehabilitation, 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><li>Willingness to learn operating equipment<\/li><li>Team Player with GREAT attitude!<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Driver's License<\/li><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Knowledge of DOT Regulations<\/li><li>Experience in heavy highway utility work&nbsp;<\/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><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/fb9406690f01-pipe-layer","%breezy_id%":"fb9406690f01","%breezy_friendly_id%":"fb9406690f01-pipe-layer","%breezy_created_date%":"2025-04-07T16:26:31.431Z","%breezy_updated_date%":"2026-08-07T13:07:17.220Z","%_wpgmp_location_city%":"Lancaster","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lancaster, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.0403279","%_wpgmp_metabox_longitude%":"-76.3041833","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"551"}},"id":3879,"infowindow_disable":false},{"source":"post","title":"Plant Maintenance Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Plant Maintenance Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You&#8217;ll Be Doing Perform mechanical maintenance, troubleshooting, and repairs on plant equipment to ensure safe and reliable operation Conduct&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/plant-maintenance-mechanic\/\" name=\"Plant Maintenance Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You&#8217;ll Be Doing Perform mechanical maintenance, troubleshooting, and repairs on plant equipment to ensure safe and reliable operation Conduct&hellip;","address":"Skaneateles, NY, USA","location":{"lat":"42.947011","city":"Skaneateles","state":"NY","country":"United States","lng":"-76.4291017","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/plant-maintenance-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"What You&#8217;ll Be Doing Perform mechanical maintenance, troubleshooting, and repairs on plant equipment to ensure safe and reliable operation Conduct&hellip;","post_content":"<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Perform mechanical maintenance, troubleshooting, and repairs on plant equipment to ensure safe and reliable operation<\/li><li>Conduct inspections and identify opportunities to improve equipment performance and longevity<\/li><li>Install, align, and maintain mechanical systems, including conveyors, crushers, and rotating equipment<\/li><li>Collaborate with team members to complete planned and unplanned maintenance activities efficiently<\/li><li>Follow safety procedures and contribute to a strong safety-first culture<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Demonstrated capability in mechanical maintenance, troubleshooting, and equipment repair<\/li><li>Ability to read and interpret technical drawings, manuals, and schematics<\/li><li>Skilled in using hand tools, power tools, and precision measuring instruments<\/li><li>Strong problem-solving abilities and commitment to safe work practices<\/li><li>Capacity to work independently and as part of a team in a fast-paced environment<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li><\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><\/p>","post_title":"Plant Maintenance Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/plant-maintenance-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Skaneateles","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Skaneateles, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Perform mechanical maintenance, troubleshooting, and repairs on plant equipment to ensure safe and reliable operation<\/li><li>Conduct inspections and identify opportunities to improve equipment performance and longevity<\/li><li>Install, align, and maintain mechanical systems, including conveyors, crushers, and rotating equipment<\/li><li>Collaborate with team members to complete planned and unplanned maintenance activities efficiently<\/li><li>Follow safety procedures and contribute to a strong safety-first culture<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Demonstrated capability in mechanical maintenance, troubleshooting, and equipment repair<\/li><li>Ability to read and interpret technical drawings, manuals, and schematics<\/li><li>Skilled in using hand tools, power tools, and precision measuring instruments<\/li><li>Strong problem-solving abilities and commitment to safe work practices<\/li><li>Capacity to work independently and as part of a team in a fast-paced environment<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li><\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/11495971ac58-plant-maintenance-mechanic","%breezy_id%":"11495971ac58","%breezy_friendly_id%":"11495971ac58-plant-maintenance-mechanic","%breezy_created_date%":"2026-02-11T01:59:00.798Z","%breezy_updated_date%":"2026-07-08T01:49:31.733Z","%_wpgmp_location_city%":"Skaneateles","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Skaneateles, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.947011","%_wpgmp_metabox_longitude%":"-76.4291017","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"563"}},"id":3880,"infowindow_disable":false},{"source":"post","title":"Heavy Duty Diesel Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Duty Diesel Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Mechanic at Jamestown NY is responsible for the preventative and reactive maintenance for a fleet of 20 trucks operating&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-duty-diesel-mechanic\/\" name=\"Heavy Duty Diesel Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Mechanic at Jamestown NY is responsible for the preventative and reactive maintenance for a fleet of 20 trucks operating&hellip;","address":"Jamestown, NY, USA","location":{"lat":"42.0970023","city":"Jamestown","state":"NY","country":"United States","lng":"-79.2353259","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-duty-diesel-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"The Mechanic at Jamestown NY is responsible for the preventative and reactive maintenance for a fleet of 20 trucks operating&hellip;","post_content":"<p>The Mechanic at Jamestown NY is responsible for the preventative and reactive<\/p>\n<p>maintenance for a fleet of 20 trucks operating out of Jamestown, Allegany and Dunkirk.<\/p>\n<p>Operating out of the Jamestown shop and reporting to the plant manager, this position<\/p>\n<p>is critical for the operational success of Heidelberg\u2019s Southern Tier business.<\/p>\n<p>What You'll Be Doing<\/p>\n<p>\uf0b7 Perform diagnostics, maintenance, and repairs on heavy-duty diesel equipment<\/p>\n<p>\uf0b7 Inspect and troubleshoot mechanical, hydraulic, and electrical systems<\/p>\n<p>\uf0b7 Ensure equipment is safe, reliable, and compliant with company standards<\/p>\n<p>\uf0b7 Maintain accurate service records and documentation<\/p>\n<p>\uf0b7 Collaborate with team members to prioritize and complete work efficiently<\/p>\n<p>What Are We Looking For<\/p>\n<p>\uf0b7 Proficiency with tools, diagnostic equipment, and repair procedures<\/p>\n<p>\uf0b7 Strong commitment to safety and preventative maintenance practices<\/p>\n<p>\uf0b7 Ability to work independently and as part of a team<\/p>\n<p>\uf0b7 Willingness to learn and adapt to new technologies and procedures<\/p>\n<p>Conditions of Employment<\/p>\n<p>\uf0b7 Successful candidate must submit to post-offer pre-employment physical<\/p>\n<p>examination, drug\/alcohol screen, and background check<\/p>\n<p>\uf0b7 Some positions require FMCSA regulated ongoing drug and alcohol testing<\/p>\n<p>Work Environment<\/p>\n<p>\uf0b7 Role operates primarily in environments where the conditions include moving<\/p>\n<p>mechanical equipment, inclement weather, heat, cold, humidity, and elevated<\/p>\n<p>noise level<\/p>\n<p>What We Offer<\/p>\n<p>\uf0b7 $26.88 - $35.50 per hour<\/p>\n<p>\uf0b7 Benefits through the Company for Medical, Dental, and Vision<\/p>\n<p>\uf0b7 Union Pension<\/p>\n<p>\uf0b7 Company paid vacation, and holidays<\/p>","post_title":"Heavy Duty Diesel Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-duty-diesel-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Jamestown","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Jamestown, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p>The Mechanic at Jamestown NY is responsible for the preventative and reactive<\/p>\n<p>maintenance for a fleet of 20 trucks operating out of Jamestown, Allegany and Dunkirk.<\/p>\n<p>Operating out of the Jamestown shop and reporting to the plant manager, this position<\/p>\n<p>is critical for the operational success of Heidelberg\u2019s Southern Tier business.<\/p>\n<p>What You'll Be Doing<\/p>\n<p>\uf0b7 Perform diagnostics, maintenance, and repairs on heavy-duty diesel equipment<\/p>\n<p>\uf0b7 Inspect and troubleshoot mechanical, hydraulic, and electrical systems<\/p>\n<p>\uf0b7 Ensure equipment is safe, reliable, and compliant with company standards<\/p>\n<p>\uf0b7 Maintain accurate service records and documentation<\/p>\n<p>\uf0b7 Collaborate with team members to prioritize and complete work efficiently<\/p>\n<p>What Are We Looking For<\/p>\n<p>\uf0b7 Proficiency with tools, diagnostic equipment, and repair procedures<\/p>\n<p>\uf0b7 Strong commitment to safety and preventative maintenance practices<\/p>\n<p>\uf0b7 Ability to work independently and as part of a team<\/p>\n<p>\uf0b7 Willingness to learn and adapt to new technologies and procedures<\/p>\n<p>Conditions of Employment<\/p>\n<p>\uf0b7 Successful candidate must submit to post-offer pre-employment physical<\/p>\n<p>examination, drug\/alcohol screen, and background check<\/p>\n<p>\uf0b7 Some positions require FMCSA regulated ongoing drug and alcohol testing<\/p>\n<p>Work Environment<\/p>\n<p>\uf0b7 Role operates primarily in environments where the conditions include moving<\/p>\n<p>mechanical equipment, inclement weather, heat, cold, humidity, and elevated<\/p>\n<p>noise level<\/p>\n<p>What We Offer<\/p>\n<p>\uf0b7 $26.88 - $35.50 per hour<\/p>\n<p>\uf0b7 Benefits through the Company for Medical, Dental, and Vision<\/p>\n<p>\uf0b7 Union Pension<\/p>\n<p>\uf0b7 Company paid vacation, and holidays<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/d124132bf2d9-heavy-duty-diesel-mechanic","%breezy_id%":"d124132bf2d9","%breezy_friendly_id%":"d124132bf2d9-heavy-duty-diesel-mechanic","%breezy_created_date%":"2026-07-03T00:24:04.973Z","%breezy_updated_date%":"2026-08-28T19:51:24.167Z","%_wpgmp_location_city%":"Jamestown","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Jamestown, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.0970023","%_wpgmp_metabox_longitude%":"-79.2353259","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"625"}},"id":3830,"infowindow_disable":false},{"source":"post","title":"Geotechnical Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geotechnical Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Opportunity The Geotechnical Engineer is responsible for evaluating soil, rock, effects of groundwater, and geologic conditions to ensure the&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geotechnical-engineer-2\/\" name=\"Geotechnical Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Opportunity The Geotechnical Engineer is responsible for evaluating soil, rock, effects of groundwater, and geologic conditions to ensure the&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\/geotechnical-engineer-2\/","zoom":19,"extra_fields":{"post_excerpt":"The Opportunity The Geotechnical Engineer is responsible for evaluating soil, rock, effects of groundwater, and geologic conditions to ensure the&hellip;","post_content":"<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">The Opportunity<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">The Geotechnical Engineer is responsible for evaluating soil, rock, effects of<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">groundwater, and geologic conditions to ensure the safe and efficient design,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">construction, and operation of mining projects. This role supports open-pit mines,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">underground mines, tailings storage facilities, waste dumps, haul roads, and related<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">infrastructure by assessing ground stability and geotechnical risks.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Geotechnical Engineers work closely with mine planning, geology, operations,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">environmental, and civil engineering teams to optimize mine safety, production, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">long-term stability.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><br><\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Responsibilities<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Conduct geotechnical investigations including drilling programs, rock and soil<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">sampling, laboratory testing, and field mapping.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Analyze rock mass behavior, slope stability, ground support requirements, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">soil mechanics.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Develop geotechnical models for open-pit and underground mining operations.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Perform advanced numerical modelling using FLAC3D and industry-leading<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">constitutive models to support complex geotechnical assessments.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Support stope sequencing, mine design optimization, and excavation stability<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">assessments.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Design and evaluate:<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Stope dimensions and estimates of ore dilution and Equivalent Linear<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Overbreak Slough (ELOS)<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Underground ground support systems<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Pit slopes and bench configurations<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Waste rock dumps<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Tailings storage facilities<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Use geotechnical software for modeling and stability analysis including advanced<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">numerical modelling approaches.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Support and contribute to Ground Control Management Plans (GCMPs), TARPs,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">and geotechnical risk management processes.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Monitor ground conditions using instrumentation such as prisms, piezometers,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">extensometers, and radar systems.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Interpret and manage geotechnical monitoring data, including prism,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">MPBX\/extensometer, radar, and other instrumentation outputs.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Identify geotechnical hazards including slope failures, rockfalls, subsidence, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">seismic risks.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Develop mitigation plans and emergency response recommendations.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Perform inspections and prepare stability assessments and technical reports.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Provide day-to-day geotechnical guidance to mine operations teams.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Work closely with operations teams to develop practical and implementable<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">geotechnical solutions.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Recommend operational changes to improve safety and production efficiency.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Support drill-and-blast optimization from a geotechnical perspective.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Participate in mine planning and scheduling meetings.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Ensure compliance with mining regulations, environmental standards, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">company safety policies.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Prepare technical documentation, risk assessments, and engineering reports.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Support permitting and regulatory submissions.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Coordinate with geologists, mine engineers, surveyors, and environmental<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">specialists.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Manage contractors and geotechnical consultants when required.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Mentor junior engineers and technicians.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Present findings and recommendations to management and stakeholders.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><br><\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">The above responsibilities are representative and may not include all assigned duties.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><br><\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Education and Experience<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Bachelor\u2019s degree in Mining Engineering, Geological Engineering, Geotechnical<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Engineering or related field.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Master\u2019s degree in Geotechnical Engineering or Rock Mechanics preferred.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 5-8+ years of mining geotechnical experience<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Knowledgeable in rock mechanics and soil mechanics<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Experience with slope stability analysis, ground support design and data<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">interpretation and technical reporting<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Experience with geotechnical and mine design software such as FLAC3D,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">Rocscience Suite (Unwedge and Dips), GeoStudio, Surpac, Vulcan, AutoCAD, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">GIS platforms.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">\uf0b7 Experience with advanced numerical modelling software, FLAC3D, will be viewed<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">favorably; however, training and mentoring will be available for suitable<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\">candidates.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5;font-family: Arial;font-size: 16px;margin: 0px;--darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3)\"><br><\/p>","post_title":"Geotechnical Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/geotechnical-engineer-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 data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">The Opportunity<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">The Geotechnical Engineer is responsible for evaluating soil, rock, effects of<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">groundwater, and geologic conditions to ensure the safe and efficient design,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">construction, and operation of mining projects. This role supports open-pit mines,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">underground mines, tailings storage facilities, waste dumps, haul roads, and related<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">infrastructure by assessing ground stability and geotechnical risks.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Geotechnical Engineers work closely with mine planning, geology, operations,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">environmental, and civil engineering teams to optimize mine safety, production, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">long-term stability.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><br><\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Responsibilities<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Conduct geotechnical investigations including drilling programs, rock and soil<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">sampling, laboratory testing, and field mapping.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Analyze rock mass behavior, slope stability, ground support requirements, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">soil mechanics.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Develop geotechnical models for open-pit and underground mining operations.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Perform advanced numerical modelling using FLAC3D and industry-leading<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">constitutive models to support complex geotechnical assessments.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Support stope sequencing, mine design optimization, and excavation stability<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">assessments.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Design and evaluate:<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Stope dimensions and estimates of ore dilution and Equivalent Linear<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Overbreak Slough (ELOS)<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Underground ground support systems<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Pit slopes and bench configurations<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Waste rock dumps<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Tailings storage facilities<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Use geotechnical software for modeling and stability analysis including advanced<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">numerical modelling approaches.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Support and contribute to Ground Control Management Plans (GCMPs), TARPs,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">and geotechnical risk management processes.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Monitor ground conditions using instrumentation such as prisms, piezometers,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">extensometers, and radar systems.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Interpret and manage geotechnical monitoring data, including prism,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">MPBX\/extensometer, radar, and other instrumentation outputs.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Identify geotechnical hazards including slope failures, rockfalls, subsidence, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">seismic risks.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Develop mitigation plans and emergency response recommendations.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Perform inspections and prepare stability assessments and technical reports.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Provide day-to-day geotechnical guidance to mine operations teams.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Work closely with operations teams to develop practical and implementable<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">geotechnical solutions.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Recommend operational changes to improve safety and production efficiency.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Support drill-and-blast optimization from a geotechnical perspective.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Participate in mine planning and scheduling meetings.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Ensure compliance with mining regulations, environmental standards, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">company safety policies.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Prepare technical documentation, risk assessments, and engineering reports.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Support permitting and regulatory submissions.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Coordinate with geologists, mine engineers, surveyors, and environmental<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">specialists.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Manage contractors and geotechnical consultants when required.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Mentor junior engineers and technicians.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Present findings and recommendations to management and stakeholders.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><br><\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">The above responsibilities are representative and may not include all assigned duties.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><br><\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Education and Experience<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Bachelor\u2019s degree in Mining Engineering, Geological Engineering, Geotechnical<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Engineering or related field.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Master\u2019s degree in Geotechnical Engineering or Rock Mechanics preferred.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 5-8+ years of mining geotechnical experience<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Knowledgeable in rock mechanics and soil mechanics<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Experience with slope stability analysis, ground support design and data<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">interpretation and technical reporting<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Experience with geotechnical and mine design software such as FLAC3D,<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">Rocscience Suite (Unwedge and Dips), GeoStudio, Surpac, Vulcan, AutoCAD, and<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">GIS platforms.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">\uf0b7 Experience with advanced numerical modelling software, FLAC3D, will be viewed<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">favorably; however, training and mentoring will be available for suitable<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\">candidates.<\/p>\n<p data-darkreader-inline-color=\"\" style=\"line-height: 1.5; font-family: Arial; font-size: 16px; color: rgb(0, 0, 0); margin: 0px; --darkreader-inline-color: var(--darkreader-text-000000, #e8e6e3);\"><br><\/p>","%category%":"","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/6be9bb633f8b-geotechnical-engineer","%breezy_id%":"6be9bb633f8b","%breezy_friendly_id%":"6be9bb633f8b-geotechnical-engineer","%breezy_created_date%":"2026-06-29T18:18:16.588Z","%breezy_updated_date%":"2026-06-30T17:25:51.124Z","%_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%":"620"}},"id":3824,"infowindow_disable":false},{"source":"post","title":"Maintenance Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY: The Mechanical Maintenance position is responsible for safely performing inspections, preventative maintenance, troubleshooting, repairs, and rebuilds on plant&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-2\/\" name=\"Maintenance Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY: The Mechanical Maintenance position is responsible for safely performing inspections, preventative maintenance, troubleshooting, repairs, and rebuilds on plant&hellip;","address":"Calera, AL, USA","location":{"lat":"33.1028965","city":"Calera","state":"AL","country":"United States","lng":"-86.7535975","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-2\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: The Mechanical Maintenance position is responsible for safely performing inspections, preventative maintenance, troubleshooting, repairs, and rebuilds on plant&hellip;","post_content":"<p><strong>POSITION SUMMARY: <\/strong>The Mechanical Maintenance position is responsible for safely performing inspections, preventative maintenance, troubleshooting, repairs, and rebuilds on plant and quarry equipment to support reliable and efficient operations. This role plays a critical part in maximizing equipment uptime, maintaining production goals, and supporting continuous improvement efforts in a heavy industrial environment.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p><\/p>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul><li>Comply with all company, MSHA, and regulatory safety policies and procedures at all times.<\/li><li>Conduct and document workplace inspections and report unsafe conditions.<\/li><li>Follow all environmental, safety, and housekeeping standards.<\/li><li>Follow lockout\/tagout (LOTO) procedures and verify zero energy state prior to performing maintenance activities.<\/li><\/ul>\n<p><\/p>\n<p><strong>Maintenance Execution<\/strong><\/p>\n<ul><li>Perform preventive, predictive, and corrective maintenance on plant equipment.<\/li><li>Disassemble, repair, and rebuild crushing, screening, and conveying equipment.<\/li><li>Install, maintain, and align mechanical components including bearings, belts, chains, and rotating equipment.<\/li><li>Install and support pneumatic and hydraulic systems.<\/li><li>Perform basic welding, torch cutting, and acetylene work as needed to support maintenance and repair activities.&nbsp;<\/li><li>Participate in continuous improvement and reliability initiatives to improve equipment uptime and maintenance efficiency.<\/li><\/ul>\n<p><\/p>\n<p><strong>Troubleshooting &amp; Repair<\/strong><\/p>\n<ul><li>Diagnose mechanical issues and perform timely repairs to minimize downtime.<\/li><li>Troubleshoot hydraulic, pneumatic, and environmental systems.<\/li><li>Utilize precision tools (e.g., micrometers, dial indicators) to support accurate diagnostics and repairs.<\/li><\/ul>\n<p><\/p>\n<p><strong>Equipment Installation &amp; Alignment<\/strong><\/p>\n<ul><li>Install and align new equipment using proper mechanical techniques and tools.<\/li><li>Perform shaft alignments and equipment setup with precision alignment tools.<\/li><li>Support rigging and lifting activities during installation and maintenance.<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Management &amp; Documentation<\/strong><\/p>\n<ul><li>Complete work orders, inspections, and maintenance reports accurately and in a timely manner.<\/li><li>Participate in work order initiation and planning processes.<\/li><li>Ensure proper use and tracking of inventory parts and materials.<\/li><\/ul>\n<p><\/p>\n<p><strong>General Maintenance Support<\/strong><\/p>\n<ul><li>Maintain assigned tools and ensure proper use of company-provided specialty tools and equipment.<\/li><li>Maintain clean and organized work areas and tools while proactively identifying and addressing maintenance, safety, and housekeeping needs.<\/li><li>Operate mobile equipment as required to support maintenance activities.<\/li><li>Support plant outages and assist with major repairs or projects.<\/li><li>Perform other duties as assigned.<\/li><\/ul>\n<p><\/p>","post_title":"Maintenance Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Calera","%location_state_id%":"AL","%location_state_name%":"Alabama","%location_city_state%":"Calera, AL","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong>POSITION SUMMARY: <\/strong>The Mechanical Maintenance position is responsible for safely performing inspections, preventative maintenance, troubleshooting, repairs, and rebuilds on plant and quarry equipment to support reliable and efficient operations. This role plays a critical part in maximizing equipment uptime, maintaining production goals, and supporting continuous improvement efforts in a heavy industrial environment.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p><\/p>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul><li>Comply with all company, MSHA, and regulatory safety policies and procedures at all times.<\/li><li>Conduct and document workplace inspections and report unsafe conditions.<\/li><li>Follow all environmental, safety, and housekeeping standards.<\/li><li>Follow lockout\/tagout (LOTO) procedures and verify zero energy state prior to performing maintenance activities.<\/li><\/ul>\n<p><\/p>\n<p><strong>Maintenance Execution<\/strong><\/p>\n<ul><li>Perform preventive, predictive, and corrective maintenance on plant equipment.<\/li><li>Disassemble, repair, and rebuild crushing, screening, and conveying equipment.<\/li><li>Install, maintain, and align mechanical components including bearings, belts, chains, and rotating equipment.<\/li><li>Install and support pneumatic and hydraulic systems.<\/li><li>Perform basic welding, torch cutting, and acetylene work as needed to support maintenance and repair activities.&nbsp;<\/li><li>Participate in continuous improvement and reliability initiatives to improve equipment uptime and maintenance efficiency.<\/li><\/ul>\n<p><\/p>\n<p><strong>Troubleshooting &amp; Repair<\/strong><\/p>\n<ul><li>Diagnose mechanical issues and perform timely repairs to minimize downtime.<\/li><li>Troubleshoot hydraulic, pneumatic, and environmental systems.<\/li><li>Utilize precision tools (e.g., micrometers, dial indicators) to support accurate diagnostics and repairs.<\/li><\/ul>\n<p><\/p>\n<p><strong>Equipment Installation &amp; Alignment<\/strong><\/p>\n<ul><li>Install and align new equipment using proper mechanical techniques and tools.<\/li><li>Perform shaft alignments and equipment setup with precision alignment tools.<\/li><li>Support rigging and lifting activities during installation and maintenance.<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Management &amp; Documentation<\/strong><\/p>\n<ul><li>Complete work orders, inspections, and maintenance reports accurately and in a timely manner.<\/li><li>Participate in work order initiation and planning processes.<\/li><li>Ensure proper use and tracking of inventory parts and materials.<\/li><\/ul>\n<p><\/p>\n<p><strong>General Maintenance Support<\/strong><\/p>\n<ul><li>Maintain assigned tools and ensure proper use of company-provided specialty tools and equipment.<\/li><li>Maintain clean and organized work areas and tools while proactively identifying and addressing maintenance, safety, and housekeeping needs.<\/li><li>Operate mobile equipment as required to support maintenance activities.<\/li><li>Support plant outages and assist with major repairs or projects.<\/li><li>Perform other duties as assigned.<\/li><\/ul>\n<p><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/324f274e5eab-maintenance-mechanic","%breezy_id%":"324f274e5eab","%breezy_friendly_id%":"324f274e5eab-maintenance-mechanic","%breezy_created_date%":"2026-07-01T22:42:23.132Z","%breezy_updated_date%":"2026-07-07T23:03:50.810Z","%_wpgmp_location_city%":"Calera","%_wpgmp_location_state%":"AL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Calera, AL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.1028965","%_wpgmp_metabox_longitude%":"-86.7535975","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"622"}},"id":3826,"infowindow_disable":false},{"source":"post","title":"Ready Mix Driver Class B","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Ready Mix Driver Class B\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You&#8217;ll Be Doing Safely operate a ready mix truck to deliver concrete to customer job sites Perform pre-trip and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/ready-mix-driver-class-b\/\" name=\"Ready Mix Driver Class B\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You&#8217;ll Be Doing Safely operate a ready mix truck to deliver concrete to customer job sites Perform pre-trip and&hellip;","address":"Onieda, NY, USA","location":{"lat":"43.0925684","city":"Onieda","state":"NY","country":"United States","lng":"-75.6512931","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/ready-mix-driver-class-b\/","zoom":19,"extra_fields":{"post_excerpt":"What You&#8217;ll Be Doing Safely operate a ready mix truck to deliver concrete to customer job sites Perform pre-trip and&hellip;","post_content":"<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Safely operate a ready mix truck to deliver concrete to customer job sites<\/li><li>Perform pre-trip and post-trip inspections and maintain vehicle cleanliness<\/li><li>Communicate effectively with dispatch and customers to ensure timely deliveries<\/li><li>Assist with yard duties and minor maintenance as needed<\/li><li>Adhere to all safety protocols and company procedures<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Valid CDL Class B with air brake endorsement<\/li><li>Ability to operate commercial vehicles safely and efficiently<\/li><li>Strong communication and teamwork skills<\/li><li>Commitment to punctuality and reliability<\/li><li>Capability to work in a physically demanding and fast-paced environment<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>","post_title":"Ready Mix Driver Class B","post_link":"https:\/\/turnerstaffing.com\/position\/ready-mix-driver-class-b\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Onieda","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Onieda, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Safely operate a ready mix truck to deliver concrete to customer job sites<\/li><li>Perform pre-trip and post-trip inspections and maintain vehicle cleanliness<\/li><li>Communicate effectively with dispatch and customers to ensure timely deliveries<\/li><li>Assist with yard duties and minor maintenance as needed<\/li><li>Adhere to all safety protocols and company procedures<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Valid CDL Class B with air brake endorsement<\/li><li>Ability to operate commercial vehicles safely and efficiently<\/li><li>Strong communication and teamwork skills<\/li><li>Commitment to punctuality and reliability<\/li><li>Capability to work in a physically demanding and fast-paced environment<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/2f8e67359487-ready-mix-driver-class-b","%breezy_id%":"2f8e67359487","%breezy_friendly_id%":"2f8e67359487-ready-mix-driver-class-b","%breezy_created_date%":"2026-07-01T22:56:19.190Z","%breezy_updated_date%":"2026-07-06T17:57:09.717Z","%_wpgmp_location_city%":"Onieda","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Onieda, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.0925684","%_wpgmp_metabox_longitude%":"-75.6512931","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"623"}},"id":3827,"infowindow_disable":false},{"source":"post","title":"Industrial Hygienist Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Hygienist Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking an Industrial Hygiene Technician I to support our mining client in the Elko, Nevada area.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-hygienist-technician\/\" name=\"Industrial Hygienist Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking an Industrial Hygiene Technician I to support our mining client in the Elko, Nevada area.&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\/industrial-hygienist-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking an Industrial Hygiene Technician I to support our mining client in the Elko, Nevada area.&hellip;","post_content":"<p>Turner Staffing Group is seeking an <strong>Industrial Hygiene Technician I<\/strong> to support our mining client in the Elko, Nevada area. This is a planned <strong>6-month contract assignment<\/strong> working four 10-hour days each week. The Industrial Hygiene Technician will assist with workplace exposure monitoring, industrial hygiene sampling, equipment calibration, data management, and regulatory compliance while promoting a safe and healthy work environment.<\/p><p>This is an excellent opportunity for candidates interested in industrial hygiene, occupational health, mining safety, or environmental health and safety (EHS).<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Conduct industrial hygiene sampling for noise, dust, gases, and other workplace exposure agents. <\/li><li>Set up, calibrate, and maintain industrial hygiene sampling equipment. <\/li><li>Perform pre- and post-calibration of monitoring equipment while maintaining calibration records. <\/li><li>Utilize dosimeter software to configure and calibrate noise monitoring equipment. <\/li><li>Enter and maintain sampling data within Cority and other required databases. <\/li><li>Upload laboratory requisitions, exposure results, and related documentation accurately. <\/li><li>Coordinate sampling schedules and communicate with site personnel regarding monitoring activities. <\/li><li>Manage inventory of sampling media, equipment, and supplies. <\/li><li>Support gas detection systems, monitor equipment inventory, and maintain operational readiness. <\/li><li>Assist with field exposure monitoring and industrial hygiene projects. <\/li><li>Participate in safety meetings and support site safety initiatives. <\/li><li>Identify unsafe conditions and communicate concerns to supervision. <\/li><li>Maintain compliance with company policies, MSHA requirements, and occupational health and safety standards. <\/li><\/ul><p><strong>Qualifications<\/strong><\/p><p>Required<\/p><ul><li>High school diploma or equivalent. <\/li><li>Strong computer skills, including Microsoft Office and database management. <\/li><li>Excellent organizational and communication skills. <\/li><li>Ability to prioritize multiple tasks while working independently. <\/li><li>Strong attention to detail. <\/li><li>Ability to work effectively both independently and as part of a team. <\/li><\/ul><p>Preferred<\/p><ul><li>Experience in mining, industrial hygiene, occupational health, safety, environmental health, or a related field. <\/li><li>Familiarity with industrial hygiene sampling equipment and exposure monitoring. <\/li><li>Experience with Cority or similar EHS management systems. <\/li><li>Knowledge of MSHA regulations and occupational health best practices. <\/li><\/ul><p><strong>Schedule<\/strong><\/p><ul><li>Monday through Thursday <\/li><li>Four 10-hour shifts per week <\/li><li>Planned 6-month assignment <\/li><\/ul><p><strong>Work Location<\/strong><\/p><ul><li>Client site in the Elko, Nevada area <\/li><\/ul><p><strong>Why Join Turner Staffing Group?<\/strong><\/p><p>At Turner Staffing Group, we connect skilled professionals with leading mining and industrial employers across the country. We are committed to matching qualified candidates with rewarding project opportunities while providing responsive support throughout every assignment.<\/p><p><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p><p>Turner Staffing Group is an Equal Opportunity Employer. Qualified applicants will receive consideration for employment without regard to race, color, religion, sex, national origin, age, disability, protected veteran status, or any other characteristic protected by applicable law.<\/p>","post_title":"Industrial Hygienist Technician","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-hygienist-technician\/","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 seeking an <strong>Industrial Hygiene Technician I<\/strong> to support our mining client in the Elko, Nevada area. This is a planned <strong>6-month contract assignment<\/strong> working four 10-hour days each week. The Industrial Hygiene Technician will assist with workplace exposure monitoring, industrial hygiene sampling, equipment calibration, data management, and regulatory compliance while promoting a safe and healthy work environment.<\/p><p>This is an excellent opportunity for candidates interested in industrial hygiene, occupational health, mining safety, or environmental health and safety (EHS).<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Conduct industrial hygiene sampling for noise, dust, gases, and other workplace exposure agents. <\/li><li>Set up, calibrate, and maintain industrial hygiene sampling equipment. <\/li><li>Perform pre- and post-calibration of monitoring equipment while maintaining calibration records. <\/li><li>Utilize dosimeter software to configure and calibrate noise monitoring equipment. <\/li><li>Enter and maintain sampling data within Cority and other required databases. <\/li><li>Upload laboratory requisitions, exposure results, and related documentation accurately. <\/li><li>Coordinate sampling schedules and communicate with site personnel regarding monitoring activities. <\/li><li>Manage inventory of sampling media, equipment, and supplies. <\/li><li>Support gas detection systems, monitor equipment inventory, and maintain operational readiness. <\/li><li>Assist with field exposure monitoring and industrial hygiene projects. <\/li><li>Participate in safety meetings and support site safety initiatives. <\/li><li>Identify unsafe conditions and communicate concerns to supervision. <\/li><li>Maintain compliance with company policies, MSHA requirements, and occupational health and safety standards. <\/li><\/ul><p><strong>Qualifications<\/strong><\/p><p>Required<\/p><ul><li>High school diploma or equivalent. <\/li><li>Strong computer skills, including Microsoft Office and database management. <\/li><li>Excellent organizational and communication skills. <\/li><li>Ability to prioritize multiple tasks while working independently. <\/li><li>Strong attention to detail. <\/li><li>Ability to work effectively both independently and as part of a team. <\/li><\/ul><p>Preferred<\/p><ul><li>Experience in mining, industrial hygiene, occupational health, safety, environmental health, or a related field. <\/li><li>Familiarity with industrial hygiene sampling equipment and exposure monitoring. <\/li><li>Experience with Cority or similar EHS management systems. <\/li><li>Knowledge of MSHA regulations and occupational health best practices. <\/li><\/ul><p><strong>Schedule<\/strong><\/p><ul><li>Monday through Thursday <\/li><li>Four 10-hour shifts per week <\/li><li>Planned 6-month assignment <\/li><\/ul><p><strong>Work Location<\/strong><\/p><ul><li>Client site in the Elko, Nevada area <\/li><\/ul><p><strong>Why Join Turner Staffing Group?<\/strong><\/p><p>At Turner Staffing Group, we connect skilled professionals with leading mining and industrial employers across the country. We are committed to matching qualified candidates with rewarding project opportunities while providing responsive support throughout every assignment.<\/p><p><strong>Candidates must be authorized to work in the United States without current or future visa sponsorship.<\/strong><\/p><p>Turner Staffing Group is an Equal Opportunity Employer. Qualified applicants will receive consideration for employment without regard to race, color, religion, sex, national origin, age, disability, protected veteran status, or any other characteristic protected by applicable law.<\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/s5rn76mk7z6gxfextmgxfwb4zy","%crelate_id%":"s5rn76mk7z6gxfextmgxfwb4zy","%crelate_created_date%":"2026-06-25T11:33:39.69Z","%crelate_updated_date%":"2026-09-27T12:00:59.48Z","%_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%":"742"}},"id":3818,"infowindow_disable":false},{"source":"post","title":"Truck Driver CDL B","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Truck Driver CDL B\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You&#8217;ll Be Doing Operate dump trailers to transport materials to and from construction sites. Perform pre-trip and post-trip inspections&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/truck-driver-cdl-b\/\" name=\"Truck Driver CDL B\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You&#8217;ll Be Doing Operate dump trailers to transport materials to and from construction sites. Perform pre-trip and post-trip inspections&hellip;","address":"Nedrow, NY, USA","location":{"lat":"42.9750662","city":"Nedrow","state":"NY","country":"United States","lng":"-76.1413132","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/truck-driver-cdl-b\/","zoom":19,"extra_fields":{"post_excerpt":"What You&#8217;ll Be Doing Operate dump trailers to transport materials to and from construction sites. Perform pre-trip and post-trip inspections&hellip;","post_content":"<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Operate dump trailers to transport materials to and from construction sites.<\/li><li>Perform pre-trip and post-trip inspections to ensure vehicle safety and maintenance.<\/li><li>Follow designated routes and adhere to delivery schedules.<\/li><li>Communicate effectively with dispatchers and site supervisors.<\/li><li>Ensure compliance with all safety regulations and company policies.<br>&nbsp;<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>CDL class A or B driver's license required.<\/li><li>Proficient in operating tri axle trucks and other heavy equipment.<\/li><li>Strong understanding of safety protocols and regulations.<\/li><li>Excellent driving and navigation skills.<\/li><li>Effective communication and teamwork abilities.<br>&nbsp;<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing.<br>&nbsp;<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<br>&nbsp;<\/li><\/ul>\n<p><strong>What We Offer<\/strong><br><\/p>\n<ul><li>401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li><li>Highly competitive benefits programs, including:<p><\/p><ul><li>Medical, Dental, and Vision along with Prescription Drug Benefits<\/li><li>Health Savings Account (HSA), Health Reimbursement Account (HRA), and Flexible Spending Account (FSA)<\/li><li>AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li><li>Paid Bonding Leave, 10 days of Paid Vacation, 40 hours of Paid Sick Leave, and 10 Paid Holidays<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p>Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p>","post_title":"Truck Driver CDL B","post_link":"https:\/\/turnerstaffing.com\/position\/truck-driver-cdl-b\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Nedrow","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Nedrow, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Operate dump trailers to transport materials to and from construction sites.<\/li><li>Perform pre-trip and post-trip inspections to ensure vehicle safety and maintenance.<\/li><li>Follow designated routes and adhere to delivery schedules.<\/li><li>Communicate effectively with dispatchers and site supervisors.<\/li><li>Ensure compliance with all safety regulations and company policies.<br>&nbsp;<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>CDL class A or B driver's license required.<\/li><li>Proficient in operating tri axle trucks and other heavy equipment.<\/li><li>Strong understanding of safety protocols and regulations.<\/li><li>Excellent driving and navigation skills.<\/li><li>Effective communication and teamwork abilities.<br>&nbsp;<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing.<br>&nbsp;<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<br>&nbsp;<\/li><\/ul>\n<p><strong>What We Offer<\/strong><br><\/p>\n<ul><li>401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li><li>Highly competitive benefits programs, including:<p><\/p><ul><li>Medical, Dental, and Vision along with Prescription Drug Benefits<\/li><li>Health Savings Account (HSA), Health Reimbursement Account (HRA), and Flexible Spending Account (FSA)<\/li><li>AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li><li>Paid Bonding Leave, 10 days of Paid Vacation, 40 hours of Paid Sick Leave, and 10 Paid Holidays<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p>Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/68bfccc6f1b6-truck-driver-cdl-b","%breezy_id%":"68bfccc6f1b6","%breezy_friendly_id%":"68bfccc6f1b6-truck-driver-cdl-b","%breezy_created_date%":"2026-04-20T23:00:18.377Z","%breezy_updated_date%":"2026-07-24T21:47:44.991Z","%_wpgmp_location_city%":"Nedrow","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Nedrow, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.9750662","%_wpgmp_metabox_longitude%":"-76.1413132","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"602"}},"id":3801,"infowindow_disable":false},{"source":"post","title":"Welder","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Welder\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You\u2019ll Be Doing Perform welding, cutting, and fabrication to support equipment repair and plant maintenance. Inspect, troubleshoot, and repair&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/welder\/\" name=\"Welder\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You\u2019ll Be Doing Perform welding, cutting, and fabrication to support equipment repair and plant maintenance. Inspect, troubleshoot, and repair&hellip;","address":"Fultonville, NY, USA","location":{"lat":"42.9478514","city":"Fultonville","state":"NY","country":"United States","lng":"-74.3704128","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/welder\/","zoom":19,"extra_fields":{"post_excerpt":"What You\u2019ll Be Doing Perform welding, cutting, and fabrication to support equipment repair and plant maintenance. Inspect, troubleshoot, and repair&hellip;","post_content":"<h2><strong>What You\u2019ll Be Doing<\/strong><\/h2>\n<ul><li>Perform welding, cutting, and fabrication to support equipment repair and plant maintenance.<\/li><li>Inspect, troubleshoot, and repair metal components and structural elements.<\/li><li>Follow safety procedures and ensure work areas and tools are maintained safely.<\/li><li>Collaborate with maintenance and operations teams to complete repair tasks efficiently.<\/li><li>Support preventive maintenance activities to ensure operational reliability.<\/li><\/ul>\n<h2><\/h2>\n<h2><strong>What We Are Looking For<\/strong><\/h2>\n<ul><li>Strong welding and fabrication capabilities across various techniques and materials.<\/li><li>Ability to interpret blueprints, drawings, and technical instructions.<\/li><li>Competence in safely operating welding tools, cutting equipment, and power tools.<\/li><li>Capacity to assess repair needs and complete tasks with attention to detail.<\/li><li>Commitment to working safely, collaboratively, and reliably in a fast-paced environment.<\/li><\/ul>\n<h2><\/h2>\n<h2><strong>Conditions of Employment<\/strong><\/h2>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li><li>Compliance with all company safety policies, procedures, and regulatory standards.<\/li><\/ul>\n<h2><\/h2>\n<h2><strong>Work Environment<\/strong><\/h2>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<h2><\/h2>\n<h2><strong>What We Offer<\/strong><\/h2>\n<ul><li>$20.00 to $30.00 per hour<\/li><li>401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li><li>Highly competitive benefits programs, including:<p><\/p><ul><li>Medical, Dental, and Vision along with Prescription Drug Benefits<\/li><li>Health Savings Account (HSA), Health Reimbursement Account (HRA) and Flexible Spending Account (FSA)<\/li><li>AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li><li>Paid Bonding Leave, 10 days of Paid Vacation, 56 hours of Paid Sick Leave and 10 Paid Holidays<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p>Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p>","post_title":"Welder","post_link":"https:\/\/turnerstaffing.com\/position\/welder\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Fultonville","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Fultonville, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<h2><strong>What You\u2019ll Be Doing<\/strong><\/h2>\n<ul><li>Perform welding, cutting, and fabrication to support equipment repair and plant maintenance.<\/li><li>Inspect, troubleshoot, and repair metal components and structural elements.<\/li><li>Follow safety procedures and ensure work areas and tools are maintained safely.<\/li><li>Collaborate with maintenance and operations teams to complete repair tasks efficiently.<\/li><li>Support preventive maintenance activities to ensure operational reliability.<\/li><\/ul>\n<h2><\/h2>\n<h2><strong>What We Are Looking For<\/strong><\/h2>\n<ul><li>Strong welding and fabrication capabilities across various techniques and materials.<\/li><li>Ability to interpret blueprints, drawings, and technical instructions.<\/li><li>Competence in safely operating welding tools, cutting equipment, and power tools.<\/li><li>Capacity to assess repair needs and complete tasks with attention to detail.<\/li><li>Commitment to working safely, collaboratively, and reliably in a fast-paced environment.<\/li><\/ul>\n<h2><\/h2>\n<h2><strong>Conditions of Employment<\/strong><\/h2>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li><li>Compliance with all company safety policies, procedures, and regulatory standards.<\/li><\/ul>\n<h2><\/h2>\n<h2><strong>Work Environment<\/strong><\/h2>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<h2><\/h2>\n<h2><strong>What We Offer<\/strong><\/h2>\n<ul><li>$20.00 to $30.00 per hour<\/li><li>401(k) retirement savings plan with an automatic company contribution as well as matching contributions<\/li><li>Highly competitive benefits programs, including:<p><\/p><ul><li>Medical, Dental, and Vision along with Prescription Drug Benefits<\/li><li>Health Savings Account (HSA), Health Reimbursement Account (HRA) and Flexible Spending Account (FSA)<\/li><li>AD&amp;D, Short- and Long-Term Disability Coverage as well as Basic Life Insurance<\/li><li>Paid Bonding Leave, 10 days of Paid Vacation, 56 hours of Paid Sick Leave and 10 Paid Holidays<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p>Equal Opportunity Employer - Minority \/ Female \/ Veteran \/ Disabled<\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/325fa0191c6a-welder","%breezy_id%":"325fa0191c6a","%breezy_friendly_id%":"325fa0191c6a-welder","%breezy_created_date%":"2026-04-20T23:04:32.445Z","%breezy_updated_date%":"2026-07-24T21:07:36.341Z","%_wpgmp_location_city%":"Fultonville","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fultonville, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.9478514","%_wpgmp_metabox_longitude%":"-74.3704128","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"603"}},"id":3802,"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    What You\u2019ll Be Doing Diagnose, repair, and maintain mobile equipment to ensure safe and reliable operation Perform inspections and identify&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-4\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You\u2019ll Be Doing Diagnose, repair, and maintain mobile equipment to ensure safe and reliable operation Perform inspections and identify&hellip;","address":"Fultonville, NY, USA","location":{"lat":"42.9478514","city":"Fultonville","state":"NY","country":"United States","lng":"-74.3704128","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-4\/","zoom":19,"extra_fields":{"post_excerpt":"What You\u2019ll Be Doing Diagnose, repair, and maintain mobile equipment to ensure safe and reliable operation Perform inspections and identify&hellip;","post_content":"<p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Diagnose, repair, and maintain mobile equipment to ensure safe and reliable operation<\/li><li>Perform inspections and identify mechanical issues before they impact production<\/li><li>Document maintenance activities and communicate equipment status to supervisors<\/li><li>Collaborate with operations teams to prioritize repairs and minimize downtime<\/li><li>Follow all safety procedures and contribute to a strong safety culture<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Strong mechanical aptitude with the ability to troubleshoot and repair mobile equipment<\/li><li>Commitment to safe work practices and adherence to established procedures<\/li><li>Capability to read and interpret technical manuals, diagrams, and work orders<\/li><li>Effective communication skills and the ability to work independently or with a team<\/li><li>Reliability, attention to detail, and adaptability in a fast\u2011paced environment<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Fultonville","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Fultonville, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Diagnose, repair, and maintain mobile equipment to ensure safe and reliable operation<\/li><li>Perform inspections and identify mechanical issues before they impact production<\/li><li>Document maintenance activities and communicate equipment status to supervisors<\/li><li>Collaborate with operations teams to prioritize repairs and minimize downtime<\/li><li>Follow all safety procedures and contribute to a strong safety culture<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Strong mechanical aptitude with the ability to troubleshoot and repair mobile equipment<\/li><li>Commitment to safe work practices and adherence to established procedures<\/li><li>Capability to read and interpret technical manuals, diagrams, and work orders<\/li><li>Effective communication skills and the ability to work independently or with a team<\/li><li>Reliability, attention to detail, and adaptability in a fast\u2011paced environment<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/352ea00cbc52-heavy-equipment-mechanic","%breezy_id%":"352ea00cbc52","%breezy_friendly_id%":"352ea00cbc52-heavy-equipment-mechanic","%breezy_created_date%":"2026-04-29T01:34:43.211Z","%breezy_updated_date%":"2026-08-31T21:31:40.557Z","%_wpgmp_location_city%":"Fultonville","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fultonville, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.9478514","%_wpgmp_metabox_longitude%":"-74.3704128","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"607"}},"id":3805,"infowindow_disable":false},{"source":"post","title":"Plant Laborer\/ Equipment operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Plant Laborer\/ Equipment operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Plant Laborer \/ Equipment Operator \ud83d\udccd Crawford, TX We are hiring a Plant Laborer \/ Equipment Operator to support daily&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/plant-laborer-equipment-operator\/\" name=\"Plant Laborer\/ Equipment operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Plant Laborer \/ Equipment Operator \ud83d\udccd Crawford, TX We are hiring a Plant Laborer \/ Equipment Operator to support daily&hellip;","address":"Crawford, TX, USA","location":{"lat":"31.5343308","city":"Crawford","state":"TX","country":"United States","lng":"-97.44307","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/plant-laborer-equipment-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Plant Laborer \/ Equipment Operator \ud83d\udccd Crawford, TX We are hiring a Plant Laborer \/ Equipment Operator to support daily&hellip;","post_content":"<h2>Plant Laborer \/ Equipment Operator<\/h2>\n\n<p>\ud83d\udccd Crawford, TX<\/p>\n\n<p>We are hiring a Plant Laborer \/ Equipment Operator to support daily operations in a limestone plant, including equipment operation, plant cleanup, and basic maintenance.<\/p>\n\n\n\n<h3>Responsibilities:<\/h3>\n\n<ul><li>Operate equipment (haul trucks, water truck, skid steer)<\/li><li>Perform pre-shift inspections and basic maintenance<\/li><li>Support plant cleanup, loading, and general labor<\/li><li>Monitor quality and properly handle materials<\/li><li>Follow all safety procedures and report issues<\/li><\/ul>\n\n\n<h3>Requirements:<\/h3>\n\n<ul><li>Ability to perform physical labor (lifting 50+ lbs)<\/li><li>Comfortable working outdoors in all weather conditions<\/li><li>Willing to work shifts, overtime, and weekends<\/li><li>Strong work ethic and ability to work independently<\/li><\/ul>\n\n\n\n<h3>Preferred:<\/h3>\n\n<ul><li>Experience in heavy equipment, mining, or industrial environments<\/li><li>Basic mechanical or maintenance knowledge<\/li><\/ul>\n\n\n\n<h3>Why Apply:<\/h3>\n\n<ul><li>Stable, full-time opportunity<\/li><li>Growth within a strong industrial environment<\/li><\/ul>","post_title":"Plant Laborer\/ Equipment operator","post_link":"https:\/\/turnerstaffing.com\/position\/plant-laborer-equipment-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Crawford","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crawford, TX","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<h2>Plant Laborer \/ Equipment Operator<\/h2>\n\n<p>\ud83d\udccd Crawford, TX<\/p>\n\n<p>We are hiring a Plant Laborer \/ Equipment Operator to support daily operations in a limestone plant, including equipment operation, plant cleanup, and basic maintenance.<\/p>\n\n\n\n<h3>Responsibilities:<\/h3>\n\n<ul><li>Operate equipment (haul trucks, water truck, skid steer)<\/li><li>Perform pre-shift inspections and basic maintenance<\/li><li>Support plant cleanup, loading, and general labor<\/li><li>Monitor quality and properly handle materials<\/li><li>Follow all safety procedures and report issues<\/li><\/ul>\n\n\n<h3>Requirements:<\/h3>\n\n<ul><li>Ability to perform physical labor (lifting 50+ lbs)<\/li><li>Comfortable working outdoors in all weather conditions<\/li><li>Willing to work shifts, overtime, and weekends<\/li><li>Strong work ethic and ability to work independently<\/li><\/ul>\n\n\n\n<h3>Preferred:<\/h3>\n\n<ul><li>Experience in heavy equipment, mining, or industrial environments<\/li><li>Basic mechanical or maintenance knowledge<\/li><\/ul>\n\n\n\n<h3>Why Apply:<\/h3>\n\n<ul><li>Stable, full-time opportunity<\/li><li>Growth within a strong industrial environment<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/692ce23c9c78-plant-laborer-equipment-operator","%breezy_id%":"692ce23c9c78","%breezy_friendly_id%":"692ce23c9c78-plant-laborer-equipment-operator","%breezy_created_date%":"2026-03-30T21:47:26.245Z","%breezy_updated_date%":"2026-07-10T17:14:53.499Z","%_wpgmp_location_city%":"Crawford","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crawford, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.5343308","%_wpgmp_metabox_longitude%":"-97.44307","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"574"}},"id":3799,"infowindow_disable":false},{"source":"post","title":"Plant Maintenance Mechanic I","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Plant Maintenance Mechanic I\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Plant Maintenance Mechanic I&nbsp; What You&#8217;ll Be Doing Perform preventive and corrective maintenance on plant equipment and machinery Troubleshoot mechanical&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/plant-maintenance-mechanic-i\/\" name=\"Plant Maintenance Mechanic I\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Plant Maintenance Mechanic I&nbsp; What You&#8217;ll Be Doing Perform preventive and corrective maintenance on plant equipment and machinery Troubleshoot mechanical&hellip;","address":"Jamesville, NY, USA","location":{"lat":"42.9914763","city":"Jamesville","state":"NY","country":"United States","lng":"-76.0717698","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/plant-maintenance-mechanic-i\/","zoom":19,"extra_fields":{"post_excerpt":"Plant Maintenance Mechanic I&nbsp; What You&#8217;ll Be Doing Perform preventive and corrective maintenance on plant equipment and machinery Troubleshoot mechanical&hellip;","post_content":"<p><strong><u>Plant Maintenance Mechanic I&nbsp;<\/u><\/strong><\/p>\n<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Perform preventive and corrective maintenance on plant equipment and machinery<\/li><li>Troubleshoot mechanical issues and implement effective solutions<\/li><li>Operate tools and equipment safely and efficiently<\/li><li>Collaborate with team members to support production goals<\/li><li>Maintain accurate records of maintenance activities<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Demonstrated mechanical aptitude and problem-solving skills<\/li><li>Ability to work independently and as part of a team<\/li><li>Familiarity with industrial tools, equipment, and safety practices<\/li><li>Willingness to learn and adapt to changing priorities<\/li><li>Strong attention to detail and commitment to quality<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p><\/p>\n<p><br><\/p>","post_title":"Plant Maintenance Mechanic I","post_link":"https:\/\/turnerstaffing.com\/position\/plant-maintenance-mechanic-i\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Jamesville","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Jamesville, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong><u>Plant Maintenance Mechanic I&nbsp;<\/u><\/strong><\/p>\n<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Perform preventive and corrective maintenance on plant equipment and machinery<\/li><li>Troubleshoot mechanical issues and implement effective solutions<\/li><li>Operate tools and equipment safely and efficiently<\/li><li>Collaborate with team members to support production goals<\/li><li>Maintain accurate records of maintenance activities<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Demonstrated mechanical aptitude and problem-solving skills<\/li><li>Ability to work independently and as part of a team<\/li><li>Familiarity with industrial tools, equipment, and safety practices<\/li><li>Willingness to learn and adapt to changing priorities<\/li><li>Strong attention to detail and commitment to quality<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p><\/p>\n<p><br><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/3adb7fca004c-plant-maintenance-mechanic-i","%breezy_id%":"3adb7fca004c","%breezy_friendly_id%":"3adb7fca004c-plant-maintenance-mechanic-i","%breezy_created_date%":"2026-02-06T21:11:13.487Z","%breezy_updated_date%":"2026-08-14T00:03:38.962Z","%_wpgmp_location_city%":"Jamesville","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Jamesville, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.9914763","%_wpgmp_metabox_longitude%":"-76.0717698","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"560"}},"id":3790,"infowindow_disable":false},{"source":"post","title":"Quarry Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Quarry Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    A few incentives offered by the company upon hire: Retention Bonus: $5,000 paid quarterly. Shift Differential: An additional $2.00 per&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/quarry-loader-operator-2nd-shift\/\" name=\"Quarry Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"A few incentives offered by the company upon hire: Retention Bonus: $5,000 paid quarterly. Shift Differential: An additional $2.00 per&hellip;","address":"Jamesville, NY, USA","location":{"lat":"42.9914763","city":"Jamesville","state":"NY","country":"United States","lng":"-76.0717698","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/quarry-loader-operator-2nd-shift\/","zoom":19,"extra_fields":{"post_excerpt":"A few incentives offered by the company upon hire: Retention Bonus: $5,000 paid quarterly. Shift Differential: An additional $2.00 per&hellip;","post_content":"<p>A few incentives offered by the company upon hire:<br><\/p>\n<ol><li>Retention Bonus: $5,000 paid quarterly.<\/li><li>Shift Differential: An additional $2.00 per hour for second-shift positions at both locations.<\/li><li>Employee Referral Bonus: A $5,000 bonus for referring an applicant to either location, paid after 180 days of continued employment for both parties.<\/li><li>Benefits: Comprehensive health, dental, vision, and vacation.<\/li><\/ol>\n<p><strong><\/strong><\/p><p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Operate loader equipment safely and efficiently to move and load materials<\/li><li>Inspect, maintain, and report equipment conditions to ensure reliable operation<\/li><li>Support production goals by supplying material to crushers, conveyors, and stockpiles<\/li><li>Follow all site safety procedures and contribute to a safe work environment<\/li><li>Communicate effectively with team members to coordinate daily activities<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate heavy equipment safely and confidently<\/li><li>Strong awareness of safety practices and commitment to following procedures<\/li><li>Capability to work independently and as part of a team in a fast\u2011paced environment<\/li><li>Skill in identifying equipment issues and reporting them promptly<\/li><li>Reliability, attention to detail, and readiness to learn site processes<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p><\/p>\n<p><strong>What We Offer<\/strong><\/p>\n<ul><li>$26.87 per hour<\/li><li>Benefits through the Union for Medical, Dental, Vision and Pension<\/li><li>Union paid vacation, sick leave and holidays<\/li><\/ul>\n<p><\/p><p><\/p>","post_title":"Quarry Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/quarry-loader-operator-2nd-shift\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Jamesville","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Jamesville, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p>A few incentives offered by the company upon hire:<br><\/p>\n<ol><li>Retention Bonus: $5,000 paid quarterly.<\/li><li>Shift Differential: An additional $2.00 per hour for second-shift positions at both locations.<\/li><li>Employee Referral Bonus: A $5,000 bonus for referring an applicant to either location, paid after 180 days of continued employment for both parties.<\/li><li>Benefits: Comprehensive health, dental, vision, and vacation.<\/li><\/ol>\n<p><strong><\/strong><\/p><p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Operate loader equipment safely and efficiently to move and load materials<\/li><li>Inspect, maintain, and report equipment conditions to ensure reliable operation<\/li><li>Support production goals by supplying material to crushers, conveyors, and stockpiles<\/li><li>Follow all site safety procedures and contribute to a safe work environment<\/li><li>Communicate effectively with team members to coordinate daily activities<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate heavy equipment safely and confidently<\/li><li>Strong awareness of safety practices and commitment to following procedures<\/li><li>Capability to work independently and as part of a team in a fast\u2011paced environment<\/li><li>Skill in identifying equipment issues and reporting them promptly<\/li><li>Reliability, attention to detail, and readiness to learn site processes<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p><\/p>\n<p><strong>What We Offer<\/strong><\/p>\n<ul><li>$26.87 per hour<\/li><li>Benefits through the Union for Medical, Dental, Vision and Pension<\/li><li>Union paid vacation, sick leave and holidays<\/li><\/ul>\n<p><\/p><p><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/1e024d7de5ff-quarry-loader-operator","%breezy_id%":"1e024d7de5ff","%breezy_friendly_id%":"1e024d7de5ff-quarry-loader-operator","%breezy_created_date%":"2026-02-10T01:33:03.727Z","%breezy_updated_date%":"2026-07-10T17:38:08.907Z","%_wpgmp_location_city%":"Jamesville","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Jamesville, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.9914763","%_wpgmp_metabox_longitude%":"-76.0717698","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"561"}},"id":3791,"infowindow_disable":false},{"source":"post","title":"Crusher Plant Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Crusher Plant Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You\u2019ll Be Doing Operate crushing equipment safely and efficiently to meet production targets Monitor plant performance and make adjustments&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/crusher-plant-operator\/\" name=\"Crusher Plant Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You\u2019ll Be Doing Operate crushing equipment safely and efficiently to meet production targets Monitor plant performance and make adjustments&hellip;","address":"Skaneateles, NY, USA","location":{"lat":"42.947011","city":"Skaneateles","state":"NY","country":"United States","lng":"-76.4291017","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/crusher-plant-operator\/","zoom":19,"extra_fields":{"post_excerpt":"What You\u2019ll Be Doing Operate crushing equipment safely and efficiently to meet production targets Monitor plant performance and make adjustments&hellip;","post_content":"<p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Operate crushing equipment safely and efficiently to meet production targets<\/li><li>Monitor plant performance and make adjustments to maintain material quality<\/li><li>Perform routine inspections and basic maintenance to ensure reliable operation<\/li><li>Identify and report equipment issues to minimize downtime<\/li><li>Follow all safety procedures and contribute to a strong safety culture<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate and monitor crushing equipment safely and effectively<\/li><li>Strong awareness of safety practices and commitment to following procedures<\/li><li>Capability to identify mechanical issues and communicate them promptly<\/li><li>Effective teamwork and communication skills in a fast\u2011paced environment<\/li><li>Reliability, attention to detail, and readiness to learn plant processes<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><\/p>","post_title":"Crusher Plant Operator","post_link":"https:\/\/turnerstaffing.com\/position\/crusher-plant-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Skaneateles","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Skaneateles, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Operate crushing equipment safely and efficiently to meet production targets<\/li><li>Monitor plant performance and make adjustments to maintain material quality<\/li><li>Perform routine inspections and basic maintenance to ensure reliable operation<\/li><li>Identify and report equipment issues to minimize downtime<\/li><li>Follow all safety procedures and contribute to a strong safety culture<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate and monitor crushing equipment safely and effectively<\/li><li>Strong awareness of safety practices and commitment to following procedures<\/li><li>Capability to identify mechanical issues and communicate them promptly<\/li><li>Effective teamwork and communication skills in a fast\u2011paced environment<\/li><li>Reliability, attention to detail, and readiness to learn plant processes<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/71a5a89b0ae9-crusher-plant-operator","%breezy_id%":"71a5a89b0ae9","%breezy_friendly_id%":"71a5a89b0ae9-crusher-plant-operator","%breezy_created_date%":"2026-02-11T02:02:51.905Z","%breezy_updated_date%":"2026-06-19T22:56:18.004Z","%_wpgmp_location_city%":"Skaneateles","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Skaneateles, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.947011","%_wpgmp_metabox_longitude%":"-76.4291017","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"564"}},"id":3792,"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    Turner Staffing Group \u2013 Heavy Equipment Operator 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\/heavy-equipment-operator-5\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Skaneateles, NY, USA","location":{"lat":"42.947011","city":"Skaneateles","state":"NY","country":"United States","lng":"-76.4291017","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-5\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p><p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<br>We\u2019ve been waiting for you! 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.<br>We are looking for a dynamic and talented mining <strong>Haul Truck Driver<\/strong> for our fast-growing, forward thinking mining services company at our project in&nbsp;<strong>Skaneateles.<\/strong><br>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.<br><br><u>You<\/u><br>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.<strong><br><\/strong><br><\/p>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Skaneateles","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Skaneateles, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong><u>Turner Staffing Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p><p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<br>We\u2019ve been waiting for you! 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.<br>We are looking for a dynamic and talented mining <strong>Haul Truck Driver<\/strong> for our fast-growing, forward thinking mining services company at our project in&nbsp;<strong>Skaneateles.<\/strong><br>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.<br><br><u>You<\/u><br>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.<strong><br><\/strong><br><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/228c99d2e5f1-heavy-equipment-operator","%breezy_id%":"228c99d2e5f1","%breezy_friendly_id%":"228c99d2e5f1-heavy-equipment-operator","%breezy_created_date%":"2026-02-11T02:10:06.333Z","%breezy_updated_date%":"2026-07-10T16:36:19.928Z","%_wpgmp_location_city%":"Skaneateles","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Skaneateles, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.947011","%_wpgmp_metabox_longitude%":"-76.4291017","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"565"}},"id":3793,"infowindow_disable":false},{"source":"post","title":"On-Site Truck Driver (NON CDL)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    On-Site Truck Driver (NON CDL)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You&#8217;ll Be Doing Operate haul trucks to transport raw materials within the plant site Perform pre- and post-operation inspections&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/on-site-truck-driver-non-cdl\/\" name=\"On-Site Truck Driver (NON CDL)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You&#8217;ll Be Doing Operate haul trucks to transport raw materials within the plant site Perform pre- and post-operation inspections&hellip;","address":"Jamesville, NY, USA","location":{"lat":"42.9914763","city":"Jamesville","state":"NY","country":"United States","lng":"-76.0717698","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/on-site-truck-driver-non-cdl\/","zoom":19,"extra_fields":{"post_excerpt":"What You&#8217;ll Be Doing Operate haul trucks to transport raw materials within the plant site Perform pre- and post-operation inspections&hellip;","post_content":"<p><strong><u><\/u><\/strong><\/p>\n<h2><strong><u><strong>What You'll Be Doing<\/strong><\/u><\/strong><\/h2>\n<p><\/p>\n<ul><li>Operate haul trucks to transport raw materials within the plant site<\/li><li>Perform pre- and post-operation inspections to ensure equipment safety<\/li><li>Communicate effectively with dispatch and plant personnel<\/li><li>Follow site safety procedures and traffic regulations<\/li><li>Assist with basic maintenance and cleaning of equipment<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to safely operate heavy equipment in a production environment<\/li><li>Strong awareness of surroundings and commitment to safety<\/li><li>Effective communication and teamwork skills<\/li><li>Willingness to follow instructions and adapt to changing conditions<\/li><li>Basic mechanical understanding and attention to operational details<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p><\/p>\n<p><br><\/p>","post_title":"On-Site Truck Driver (NON CDL)","post_link":"https:\/\/turnerstaffing.com\/position\/on-site-truck-driver-non-cdl\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Jamesville","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Jamesville, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong><u><\/u><\/strong><\/p>\n<h2><strong><u><strong>What You'll Be Doing<\/strong><\/u><\/strong><\/h2>\n<p><\/p>\n<ul><li>Operate haul trucks to transport raw materials within the plant site<\/li><li>Perform pre- and post-operation inspections to ensure equipment safety<\/li><li>Communicate effectively with dispatch and plant personnel<\/li><li>Follow site safety procedures and traffic regulations<\/li><li>Assist with basic maintenance and cleaning of equipment<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to safely operate heavy equipment in a production environment<\/li><li>Strong awareness of surroundings and commitment to safety<\/li><li>Effective communication and teamwork skills<\/li><li>Willingness to follow instructions and adapt to changing conditions<\/li><li>Basic mechanical understanding and attention to operational details<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p><\/p>\n<p><br><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/d80813d0cf03-on-site-truck-driver-non-cdl","%breezy_id%":"d80813d0cf03","%breezy_friendly_id%":"d80813d0cf03-on-site-truck-driver-non-cdl","%breezy_created_date%":"2026-02-06T20:09:49.540Z","%breezy_updated_date%":"2026-07-10T17:41:36.512Z","%_wpgmp_location_city%":"Jamesville","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Jamesville, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.9914763","%_wpgmp_metabox_longitude%":"-76.0717698","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"557"}},"id":3786,"infowindow_disable":false},{"source":"post","title":"Yard Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Yard Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Yard Loader Operator&nbsp; What You\u2019ll Be Doing Operate loader equipment safely to move, load, and organize materials Perform routine equipment&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/yard-loader-operator\/\" name=\"Yard Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Yard Loader Operator&nbsp; What You\u2019ll Be Doing Operate loader equipment safely to move, load, and organize materials Perform routine equipment&hellip;","address":"Syracuse, NY, USA","location":{"lat":"43.0494832","city":"Syracuse","state":"NY","country":"United States","lng":"-76.1473977","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/yard-loader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Yard Loader Operator&nbsp; What You\u2019ll Be Doing Operate loader equipment safely to move, load, and organize materials Perform routine equipment&hellip;","post_content":"<p><strong><u>Yard Loader Operator&nbsp;<\/u><\/strong><br><\/p>\n<p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Operate loader equipment safely to move, load, and organize materials<\/li><li>Perform routine equipment inspections and basic maintenance<\/li><li>Manage stockpiles and support yard material flow<\/li><li>Follow all safety procedures and maintain a clean, organized work area<\/li><li>Communicate effectively with team members to coordinate daily tasks<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate heavy equipment safely and confidently<\/li><li>Strong awareness of safety practices and commitment to following procedures<\/li><li>Capability to identify equipment issues and report them promptly<\/li><li>Effective communication skills and ability to work independently or with a team<\/li><li>Reliability, attention to detail, and readiness to learn yard operations<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><br><\/p><p><strong><u><br><\/u><\/strong><strong><u><br><\/u><\/strong><\/p>","post_title":"Yard Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/yard-loader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Syracuse","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Syracuse, NY","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong><u>Yard Loader Operator&nbsp;<\/u><\/strong><br><\/p>\n<p><strong>What You\u2019ll Be Doing<\/strong><\/p>\n<ul><li>Operate loader equipment safely to move, load, and organize materials<\/li><li>Perform routine equipment inspections and basic maintenance<\/li><li>Manage stockpiles and support yard material flow<\/li><li>Follow all safety procedures and maintain a clean, organized work area<\/li><li>Communicate effectively with team members to coordinate daily tasks<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate heavy equipment safely and confidently<\/li><li>Strong awareness of safety practices and commitment to following procedures<\/li><li>Capability to identify equipment issues and report them promptly<\/li><li>Effective communication skills and ability to work independently or with a team<\/li><li>Reliability, attention to detail, and readiness to learn yard operations<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><br><\/p><p><strong><u><br><\/u><\/strong><strong><u><br><\/u><\/strong><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/6129eacf2a04-yard-loader-operator","%breezy_id%":"6129eacf2a04","%breezy_friendly_id%":"6129eacf2a04-yard-loader-operator","%breezy_created_date%":"2026-02-06T20:28:57.035Z","%breezy_updated_date%":"2026-06-19T22:49:05.327Z","%_wpgmp_location_city%":"Syracuse","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Syracuse, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.0494832","%_wpgmp_metabox_longitude%":"-76.1473977","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"558"}},"id":3787,"infowindow_disable":false},{"source":"post","title":"Plant Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Plant Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Plant Operator&nbsp; A&nbsp;few incentives offered by the company upon hire: Retention Bonus: $5,000 paid quarterly. Shift Differential: An additional $2.00&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/plant-operator\/\" name=\"Plant Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Plant Operator&nbsp; A&nbsp;few incentives offered by the company upon hire: Retention Bonus: $5,000 paid quarterly. Shift Differential: An additional $2.00&hellip;","address":"Jamesville, NY, USA","location":{"lat":"42.9914763","city":"Jamesville","state":"NY","country":"United States","lng":"-76.0717698","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/plant-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Plant Operator&nbsp; A&nbsp;few incentives offered by the company upon hire: Retention Bonus: $5,000 paid quarterly. Shift Differential: An additional $2.00&hellip;","post_content":"<p><u><strong>Plant Operator&nbsp;<\/strong><\/u><\/p><p><u><strong><br><\/strong><\/u><\/p><p>A&nbsp;few incentives offered by the company upon hire:<br><\/p>\n<ol><li>Retention Bonus: $5,000 paid quarterly.<\/li><li>Shift Differential: An additional $2.00 per hour for second-shift positions at both locations.<\/li><li>Employee Referral Bonus: A $5,000 bonus for referring an applicant to either location, paid after 180 days of continued employment for both parties.<\/li><li>Benefits: Comprehensive health, dental, vision, and vacation.<\/li><\/ol><p><u><strong><br><\/strong><\/u><\/p>\n<p><strong><\/strong><\/p>\n<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Operate and monitor plant equipment to ensure optimal performance<\/li><li>Perform routine inspections and basic maintenance tasks<\/li><li>Record production data and report equipment issues promptly<\/li><li>Support safe and efficient material handling and processing<\/li><li>Collaborate with team members to meet production targets<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate and troubleshoot industrial machinery<\/li><li>Strong awareness of safety protocols and procedures<\/li><li>Effective communication and teamwork skills<\/li><li>Willingness to learn and adapt to changing operational needs<\/li><li>Attention to detail and commitment to quality standards<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p><\/p>\n<p><\/p>","post_title":"Plant Operator","post_link":"https:\/\/turnerstaffing.com\/position\/plant-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Jamesville","%location_state_id%":"NY","%location_state_name%":"New York","%location_city_state%":"Jamesville, NY","%education%":"","%department%":"TSG","%description%":"<p><u><strong>Plant Operator&nbsp;<\/strong><\/u><\/p><p><u><strong><br><\/strong><\/u><\/p><p>A&nbsp;few incentives offered by the company upon hire:<br><\/p>\n<ol><li>Retention Bonus: $5,000 paid quarterly.<\/li><li>Shift Differential: An additional $2.00 per hour for second-shift positions at both locations.<\/li><li>Employee Referral Bonus: A $5,000 bonus for referring an applicant to either location, paid after 180 days of continued employment for both parties.<\/li><li>Benefits: Comprehensive health, dental, vision, and vacation.<\/li><\/ol><p><u><strong><br><\/strong><\/u><\/p>\n<p><strong><\/strong><\/p>\n<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Operate and monitor plant equipment to ensure optimal performance<\/li><li>Perform routine inspections and basic maintenance tasks<\/li><li>Record production data and report equipment issues promptly<\/li><li>Support safe and efficient material handling and processing<\/li><li>Collaborate with team members to meet production targets<\/li><\/ul>\n<p><\/p>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Ability to operate and troubleshoot industrial machinery<\/li><li>Strong awareness of safety protocols and procedures<\/li><li>Effective communication and teamwork skills<\/li><li>Willingness to learn and adapt to changing operational needs<\/li><li>Attention to detail and commitment to quality standards<\/li><\/ul>\n<p><\/p>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing<\/li><\/ul>\n<p><\/p>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level<\/li><\/ul>\n<p><\/p>\n<p><\/p>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/fefee85c572d-plant-operator","%breezy_id%":"fefee85c572d","%breezy_friendly_id%":"fefee85c572d-plant-operator","%breezy_created_date%":"2026-02-06T20:43:14.375Z","%breezy_updated_date%":"2026-08-14T00:03:37.988Z","%_wpgmp_location_city%":"Jamesville","%_wpgmp_location_state%":"NY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Jamesville, NY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.9914763","%_wpgmp_metabox_longitude%":"-76.0717698","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"559"}},"id":3788,"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 an Underground Ore Control Geologist to support a world-class gold mining operation in the Elko,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist-5\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking an Underground Ore Control Geologist to support a world-class gold mining operation in the Elko,&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\/geologist-5\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking an Underground Ore Control Geologist to support a world-class gold mining operation in the Elko,&hellip;","post_content":"<p><\/p><p>Turner Staffing Group is seeking an <strong>Underground Ore Control Geologist<\/strong> to support a world-class gold mining operation in the Elko, Nevada area. This role is primarily focused on ore control activities, including underground geologic mapping, muck routing, grade control support, drill core and reverse circulation (RC) logging, and sample management. The successful candidate will work closely with mine operations to ensure accurate geological interpretation and ore delineation while supporting safe and efficient production.<\/p><p>This is an excellent opportunity for an early-career geologist to gain hands-on experience in underground gold mining and ore control while working alongside industry-leading professionals.<\/p><p><\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Conduct underground geologic mapping to support ore control and production activities. <\/li><li>Perform muck routing and provide geological guidance for material classification. <\/li><li>Assist with grade control programs and ore\/waste boundary identification. <\/li><li>Log diamond drill core and reverse circulation (RC) drill cuttings. <\/li><li>Collect, organize, track, and manage geological samples and assay submissions. <\/li><li>Maintain accurate geological databases, maps, and production records. <\/li><li>Collaborate with mine operations, engineering, and technical services personnel. <\/li><li>Ensure compliance with site safety, environmental, and operational procedures. <\/li><li>Support exploration, resource definition, and production geology initiatives as needed. <\/li><li>Perform other duties as assigned.<\/li><\/ul><p><strong>Qualifications<\/strong><\/p><p>Required<\/p><ul><li>Bachelor's degree in Geology, Geological Engineering, or a related earth science discipline. <\/li><li>Strong understanding of geological mapping, sampling, and logging techniques. <\/li><li>Ability to work in an underground mining environment. <\/li><li>Strong organizational, communication, and data management skills. <\/li><li>Proficiency with Microsoft Office applications. <\/li><li>Must be authorized to work in the United States without current or future visa sponsorship. <\/li><\/ul><p>Preferred<\/p><ul><li>Minimum one (1) year of underground geology or ore control experience preferred. <\/li><li>Experience in underground gold mining operations strongly preferred. <\/li><li>Familiarity with grade control practices, ore delineation, and production geology. <\/li><li>Experience with geological database management and logging software.<\/li><\/ul><p><strong>Physical Requirements<\/strong><\/p><ul><li>Ability to work underground in varying environmental conditions. <\/li><li>Ability to walk uneven terrain, climb ladders, and navigate active mining areas. <\/li><li>Ability to lift and move geological samples and core boxes as needed. <\/li><li>Ability to wear required personal protective equipment (PPE). <\/li><\/ul><p><strong>Why Join Turner Staffing Group?<\/strong><\/p><ul><li>Opportunity to work on a world-class gold mining project. <\/li><li>Exposure to industry-leading geological and mining practices. <\/li><li>Competitive compensation based on experience. <\/li><li>Potential for project extensions and future opportunities within Turner Staffing Group's mining network. <\/li><\/ul><p><strong>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, protected veteran status, or any other protected characteristic under applicable law.<\/strong><\/p>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist-5\/","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><\/p><p>Turner Staffing Group is seeking an <strong>Underground Ore Control Geologist<\/strong> to support a world-class gold mining operation in the Elko, Nevada area. This role is primarily focused on ore control activities, including underground geologic mapping, muck routing, grade control support, drill core and reverse circulation (RC) logging, and sample management. The successful candidate will work closely with mine operations to ensure accurate geological interpretation and ore delineation while supporting safe and efficient production.<\/p><p>This is an excellent opportunity for an early-career geologist to gain hands-on experience in underground gold mining and ore control while working alongside industry-leading professionals.<\/p><p><\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li>Conduct underground geologic mapping to support ore control and production activities. <\/li><li>Perform muck routing and provide geological guidance for material classification. <\/li><li>Assist with grade control programs and ore\/waste boundary identification. <\/li><li>Log diamond drill core and reverse circulation (RC) drill cuttings. <\/li><li>Collect, organize, track, and manage geological samples and assay submissions. <\/li><li>Maintain accurate geological databases, maps, and production records. <\/li><li>Collaborate with mine operations, engineering, and technical services personnel. <\/li><li>Ensure compliance with site safety, environmental, and operational procedures. <\/li><li>Support exploration, resource definition, and production geology initiatives as needed. <\/li><li>Perform other duties as assigned.<\/li><\/ul><p><strong>Qualifications<\/strong><\/p><p>Required<\/p><ul><li>Bachelor's degree in Geology, Geological Engineering, or a related earth science discipline. <\/li><li>Strong understanding of geological mapping, sampling, and logging techniques. <\/li><li>Ability to work in an underground mining environment. <\/li><li>Strong organizational, communication, and data management skills. <\/li><li>Proficiency with Microsoft Office applications. <\/li><li>Must be authorized to work in the United States without current or future visa sponsorship. <\/li><\/ul><p>Preferred<\/p><ul><li>Minimum one (1) year of underground geology or ore control experience preferred. <\/li><li>Experience in underground gold mining operations strongly preferred. <\/li><li>Familiarity with grade control practices, ore delineation, and production geology. <\/li><li>Experience with geological database management and logging software.<\/li><\/ul><p><strong>Physical Requirements<\/strong><\/p><ul><li>Ability to work underground in varying environmental conditions. <\/li><li>Ability to walk uneven terrain, climb ladders, and navigate active mining areas. <\/li><li>Ability to lift and move geological samples and core boxes as needed. <\/li><li>Ability to wear required personal protective equipment (PPE). <\/li><\/ul><p><strong>Why Join Turner Staffing Group?<\/strong><\/p><ul><li>Opportunity to work on a world-class gold mining project. <\/li><li>Exposure to industry-leading geological and mining practices. <\/li><li>Competitive compensation based on experience. <\/li><li>Potential for project extensions and future opportunities within Turner Staffing Group's mining network. <\/li><\/ul><p><strong>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, protected veteran status, or any other protected characteristic under applicable law.<\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/ntuxb5af4fxad4656qkb4urusw","%crelate_id%":"ntuxb5af4fxad4656qkb4urusw","%crelate_created_date%":"2026-06-19T00:19:28.71Z","%crelate_updated_date%":"2026-08-12T19:25:33.44Z","%_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%":"746"}},"id":3784,"infowindow_disable":false},{"source":"post","title":"Exploration Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Exploration Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/exploration-manager\/\" name=\"Exploration Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in&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\/exploration-manager\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in&hellip;","post_content":"<p><strong><\/strong><\/p><p>We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in Nevada. This role is responsible for managing near-mine and regional exploration programs, overseeing target generation and project development, and leading a high-performing technical team focused on resource growth and discovery.<\/p><p>Nevada-based candidates are preferred; however, qualified candidates throughout the United States will be considered. Candidates should be comfortable working in remote locations and have demonstrated success operating in remote mining and exploration environments.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li><p>Assess exploration potential, define targets, and develop and manage exploration programs.<\/p><\/li><li><p>Lead target generation, assessment, and project pipeline management activities.<\/p><\/li><li><p>Design, evaluate, plan, and prioritize exploration targets at various stages of advancement.<\/p><\/li><li><p>Contribute to drill planning for resource discovery, resource growth, and program optimization.<\/p><\/li><li><p>Coordinate and sequence exploration activities including geological, geochemical, geophysical, and drilling programs.<\/p><\/li><li><p>Ensure effective utilization of exploration data to support geological interpretation and decision-making.<\/p><\/li><li><p>Implement and oversee QA\/QC programs and procedures across all exploration activities.<\/p><\/li><li><p>Review QA\/QC data and ensure any issues are identified and addressed promptly.<\/p><\/li><li><p>Mentor, develop, and strengthen exploration team capabilities.<\/p><\/li><li><p>Perform and support geological and structural modeling as required.<\/p><\/li><\/ul><p><strong>Qualifications<\/strong><\/p><ul><li><p>15+ years of exploration experience with Carlin-type, epithermal gold-silver, and similar deposit styles.<\/p><\/li><li><p>Minimum 5 years of leadership experience in exploration management within the mining industry.<\/p><\/li><li><p>Experience with both near-mine and regional exploration programs.<\/p><\/li><li><p>Experience advancing both surface and underground projects.<\/p><\/li><li><p>Strong understanding of QA\/QC principles, implementation, and data evaluation.<\/p><\/li><li><p>Proficiency with exploration and mining software applications.<\/p><\/li><li><p>GIS and 3D modeling experience preferred.<\/p><\/li><li><p>Excellent leadership, communication, organizational, and team-building skills.<\/p><\/li><li><p>Ability to manage multiple priorities and meet project deadlines.<\/p><\/li><li><p>Bachelor's degree or higher in Geosciences or a related field; field camp experience required.<\/p><\/li><li><p>Demonstrated ability and willingness to work in remote mining and exploration environments.<\/p><\/li><\/ul><p><strong>Safety, Environmental, and Compliance<\/strong><\/p><ul><li><p>Demonstrate an uncompromising commitment to safety and environmental stewardship.<\/p><\/li><li><p>Adhere to all company safety policies, procedures, and regulatory requirements.<\/p><\/li><li><p>Identify, report, and correct unsafe conditions and behaviors.<\/p><\/li><li><p>Promote a culture of safe and responsible work practices.<\/p><\/li><li><p>Nevada Preferred (Remote Site-Based Role)<\/p><\/li><li><p>Open to candidates located anywhere in the United States who are willing to relocate and work in a remote mining environment.<\/p><\/li><\/ul><p><strong>Work Authorization Requirement<\/strong><\/p><p>Candidates must be legally authorized to work in the United States at the time of hire and throughout employment. Visa sponsorship is not available for this position.<\/p>","post_title":"Exploration Manager","post_link":"https:\/\/turnerstaffing.com\/position\/exploration-manager\/","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><strong><\/strong><\/p><p>We are seeking an experienced Exploration Manager to lead exploration activities supporting a large-scale gold and silver mining operation in Nevada. This role is responsible for managing near-mine and regional exploration programs, overseeing target generation and project development, and leading a high-performing technical team focused on resource growth and discovery.<\/p><p>Nevada-based candidates are preferred; however, qualified candidates throughout the United States will be considered. Candidates should be comfortable working in remote locations and have demonstrated success operating in remote mining and exploration environments.<\/p><p><strong>Key Responsibilities<\/strong><\/p><ul><li><p>Assess exploration potential, define targets, and develop and manage exploration programs.<\/p><\/li><li><p>Lead target generation, assessment, and project pipeline management activities.<\/p><\/li><li><p>Design, evaluate, plan, and prioritize exploration targets at various stages of advancement.<\/p><\/li><li><p>Contribute to drill planning for resource discovery, resource growth, and program optimization.<\/p><\/li><li><p>Coordinate and sequence exploration activities including geological, geochemical, geophysical, and drilling programs.<\/p><\/li><li><p>Ensure effective utilization of exploration data to support geological interpretation and decision-making.<\/p><\/li><li><p>Implement and oversee QA\/QC programs and procedures across all exploration activities.<\/p><\/li><li><p>Review QA\/QC data and ensure any issues are identified and addressed promptly.<\/p><\/li><li><p>Mentor, develop, and strengthen exploration team capabilities.<\/p><\/li><li><p>Perform and support geological and structural modeling as required.<\/p><\/li><\/ul><p><strong>Qualifications<\/strong><\/p><ul><li><p>15+ years of exploration experience with Carlin-type, epithermal gold-silver, and similar deposit styles.<\/p><\/li><li><p>Minimum 5 years of leadership experience in exploration management within the mining industry.<\/p><\/li><li><p>Experience with both near-mine and regional exploration programs.<\/p><\/li><li><p>Experience advancing both surface and underground projects.<\/p><\/li><li><p>Strong understanding of QA\/QC principles, implementation, and data evaluation.<\/p><\/li><li><p>Proficiency with exploration and mining software applications.<\/p><\/li><li><p>GIS and 3D modeling experience preferred.<\/p><\/li><li><p>Excellent leadership, communication, organizational, and team-building skills.<\/p><\/li><li><p>Ability to manage multiple priorities and meet project deadlines.<\/p><\/li><li><p>Bachelor's degree or higher in Geosciences or a related field; field camp experience required.<\/p><\/li><li><p>Demonstrated ability and willingness to work in remote mining and exploration environments.<\/p><\/li><\/ul><p><strong>Safety, Environmental, and Compliance<\/strong><\/p><ul><li><p>Demonstrate an uncompromising commitment to safety and environmental stewardship.<\/p><\/li><li><p>Adhere to all company safety policies, procedures, and regulatory requirements.<\/p><\/li><li><p>Identify, report, and correct unsafe conditions and behaviors.<\/p><\/li><li><p>Promote a culture of safe and responsible work practices.<\/p><\/li><li><p>Nevada Preferred (Remote Site-Based Role)<\/p><\/li><li><p>Open to candidates located anywhere in the United States who are willing to relocate and work in a remote mining environment.<\/p><\/li><\/ul><p><strong>Work Authorization Requirement<\/strong><\/p><p>Candidates must be legally authorized to work in the United States at the time of hire and throughout employment. Visa sponsorship is not available for this position.<\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/m5s1dze4dw5fpper4d91ip3a9r","%crelate_id%":"m5s1dze4dw5fpper4d91ip3a9r","%crelate_created_date%":"2026-06-15T19:03:20.22Z","%crelate_updated_date%":"2026-06-26T13:38:39.81Z","%_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%":"749"}},"id":3782,"infowindow_disable":false},{"source":"post","title":"CDL Driver &#8211; Ready Mix","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    CDL Driver &#8211; Ready Mix\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You&#8217;ll Be Doing Safely operate a ready-mix concrete truck to deliver products to customers. Perform pre-trip and post-trip inspections&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/ready-mix-cdl-driver\/\" name=\"CDL Driver &#8211; Ready Mix\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You&#8217;ll Be Doing Safely operate a ready-mix concrete truck to deliver products to customers. Perform pre-trip and post-trip inspections&hellip;","address":"Pittsburgh, PA, USA","location":{"lat":"40.4386612","city":"Pittsburgh","state":"PA","country":"United States","lng":"-79.9972352","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/ready-mix-cdl-driver\/","zoom":19,"extra_fields":{"post_excerpt":"What You&#8217;ll Be Doing Safely operate a ready-mix concrete truck to deliver products to customers. Perform pre-trip and post-trip inspections&hellip;","post_content":"<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Safely operate a ready-mix concrete truck to deliver products to customers.<\/li><li>Perform pre-trip and post-trip inspections of the vehicle.<\/li><li>Ensure accurate delivery tickets and maintain communication with dispatch.<\/li><li>Assist with the loading and unloading of materials.<\/li><li>Adhere to all safety protocols and regulations.<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Valid commercial driver\u2019s license (CDL) with a clean driving record.<\/li><li>Ability to operate and maintain equipment safely and efficiently.<\/li><li>Strong communication and customer service skills.<\/li><li>Physical capability to lift and move heavy materials.<\/li><li>Commitment to safety and compliance with all regulations.<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing.<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><strong>What We Offer<\/strong><\/p>\n<ul><li>$33.50 per hour<\/li><\/ul>","post_title":"CDL Driver &#8211; Ready Mix","post_link":"https:\/\/turnerstaffing.com\/position\/ready-mix-cdl-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Pittsburgh","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Pittsburgh, PA","%education%":"High School or Equivalent","%department%":"TSG","%description%":"<p><strong>What You'll Be Doing<\/strong><\/p>\n<ul><li>Safely operate a ready-mix concrete truck to deliver products to customers.<\/li><li>Perform pre-trip and post-trip inspections of the vehicle.<\/li><li>Ensure accurate delivery tickets and maintain communication with dispatch.<\/li><li>Assist with the loading and unloading of materials.<\/li><li>Adhere to all safety protocols and regulations.<\/li><\/ul>\n<p><strong>What Are We Looking For<\/strong><\/p>\n<ul><li>Valid commercial driver\u2019s license (CDL) with a clean driving record.<\/li><li>Ability to operate and maintain equipment safely and efficiently.<\/li><li>Strong communication and customer service skills.<\/li><li>Physical capability to lift and move heavy materials.<\/li><li>Commitment to safety and compliance with all regulations.<\/li><\/ul>\n<p><strong>Conditions of Employment<\/strong><\/p>\n<ul><li>Successful candidate must submit to post-offer pre-employment physical examination, drug\/alcohol screen, and background check.<\/li><li>Some positions require FMCSA regulated ongoing drug and alcohol testing.<\/li><\/ul>\n<p><strong>Work Environment<\/strong><\/p>\n<ul><li>Role operates primarily in environments where the conditions include moving mechanical equipment, inclement weather, heat, cold, humidity, and elevated noise level.<\/li><\/ul>\n<p><strong>What We Offer<\/strong><\/p>\n<ul><li>$33.50 per hour<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/1a809a311d88-cdl-driver-ready-mix","%breezy_id%":"1a809a311d88","%breezy_friendly_id%":"1a809a311d88-cdl-driver-ready-mix","%breezy_created_date%":"2026-06-09T19:50:19.805Z","%breezy_updated_date%":"2026-07-22T13:28:59.700Z","%_wpgmp_location_city%":"Pittsburgh","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pittsburgh, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.4386612","%_wpgmp_metabox_longitude%":"-79.9972352","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"619"}},"id":3772,"infowindow_disable":false},{"source":"post","title":"Ground Crew\/Maintenance Crew","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Ground Crew\/Maintenance Crew\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Overview Turner Staffing Group is hiring Ground Crew \/ Maintenance Technicians to support a mining operation in Hinkley, California. This&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/ground-crew-maintenance-crew\/\" name=\"Ground Crew\/Maintenance Crew\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Overview Turner Staffing Group is hiring Ground Crew \/ Maintenance Technicians to support a mining operation in Hinkley, California. This&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\/ground-crew-maintenance-crew\/","zoom":19,"extra_fields":{"post_excerpt":"Overview Turner Staffing Group is hiring Ground Crew \/ Maintenance Technicians to support a mining operation in Hinkley, California. This&hellip;","post_content":"<h3><strong>Overview<\/strong><\/h3>\n<p>Turner Staffing Group is hiring Ground Crew \/ Maintenance Technicians to support a mining operation in Hinkley, California. This role is essential to keeping the site running efficiently by supporting equipment maintenance, performing general labor tasks, and assisting operators and supervisors with day-to-day operations.<\/p>\n<p>This is a great opportunity for mechanically inclined individuals who are hands-on, dependable, and looking to grow within the mining or heavy equipment industry.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with routine maintenance and basic repairs on heavy equipment and plant machinery\n<\/li>\n<li>\nPerform general labor duties including cleanup, shoveling, and site housekeeping\n<\/li>\n<li>\nSupport equipment operators and maintenance personnel as needed\n<\/li>\n<li>\nConduct inspections and report wear, damage, or safety concerns\n<\/li>\n<li>\nAssist with fueling, greasing, and servicing equipment\n<\/li>\n<li>\nMaintain clean and organized work areas\n<\/li>\n<li>\nFollow all site safety policies and MSHA regulations\n<\/li>\n<li>\nWork in and around active mining equipment safely and efficiently\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMechanical aptitude or prior maintenance experience preferred\n<\/li>\n<li>\nExperience in mining, quarry, construction, or industrial environments is a plus\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 perform physically demanding work in outdoor conditions\n<\/li>\n<li>\nStrong work ethic and willingness to learn\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>\nHands-on individuals who are not afraid to get dirty and work hard\n<\/li>\n<li>\nTeam players who can take direction and support multiple areas of the operation\n<\/li>\n<li>\nCandidates who are mechanically inclined and eager to develop new skills\n<\/li>\n<li>\nDependable workers who show up ready to contribute every day<\/li><\/ul>","post_title":"Ground Crew\/Maintenance Crew","post_link":"https:\/\/turnerstaffing.com\/position\/ground-crew-maintenance-crew\/","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 Ground Crew \/ Maintenance Technicians to support a mining operation in Hinkley, California. This role is essential to keeping the site running efficiently by supporting equipment maintenance, performing general labor tasks, and assisting operators and supervisors with day-to-day operations.<\/p>\n<p>This is a great opportunity for mechanically inclined individuals who are hands-on, dependable, and looking to grow within the mining or heavy equipment industry.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\nAssist with routine maintenance and basic repairs on heavy equipment and plant machinery\n<\/li>\n<li>\nPerform general labor duties including cleanup, shoveling, and site housekeeping\n<\/li>\n<li>\nSupport equipment operators and maintenance personnel as needed\n<\/li>\n<li>\nConduct inspections and report wear, damage, or safety concerns\n<\/li>\n<li>\nAssist with fueling, greasing, and servicing equipment\n<\/li>\n<li>\nMaintain clean and organized work areas\n<\/li>\n<li>\nFollow all site safety policies and MSHA regulations\n<\/li>\n<li>\nWork in and around active mining equipment safely and efficiently\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\nMechanical aptitude or prior maintenance experience preferred\n<\/li>\n<li>\nExperience in mining, quarry, construction, or industrial environments is a plus\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 perform physically demanding work in outdoor conditions\n<\/li>\n<li>\nStrong work ethic and willingness to learn\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>\nHands-on individuals who are not afraid to get dirty and work hard\n<\/li>\n<li>\nTeam players who can take direction and support multiple areas of the operation\n<\/li>\n<li>\nCandidates who are mechanically inclined and eager to develop new skills\n<\/li>\n<li>\nDependable workers who show up ready to contribute every day<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turner-mining-group.breezy.hr\/p\/db7c429082b4-ground-crew-maintenance-crew","%breezy_id%":"db7c429082b4","%breezy_friendly_id%":"db7c429082b4-ground-crew-maintenance-crew","%breezy_created_date%":"2026-04-03T20:03:49.860Z","%breezy_updated_date%":"2026-07-11T15:05:21.485Z","%_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","%rank_math_analytic_object_id%":"578"}},"id":3768,"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-07-08T13:08:29.452Z","%_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","%rank_math_analytic_object_id%":"617"}},"id":3760,"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","%rank_math_analytic_object_id%":"562"}},"id":3754,"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","%rank_math_analytic_object_id%":"548"}},"id":3750,"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-08-19T18:09:23.53Z","%_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%":"745"}},"id":3749,"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-09-18T15:27:57.028Z","%_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%":"614"}},"id":3741,"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","%rank_math_analytic_object_id%":"616"}},"id":3744,"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\/\" 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\/","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\/","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%":"609"}},"id":3729,"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-4\/\" 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-4\/","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-4\/","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%":"610"}},"id":3730,"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","%rank_math_analytic_object_id%":"611"}},"id":3731,"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-08-28T20:25:06.863Z","%_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%":"600"}},"id":3722,"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\/\" 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\/","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\/","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-09-18T18:06:51.553Z","%_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%":"601"}},"id":3726,"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-traveling-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-traveling-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-traveling-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%":"608"}},"id":3728,"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":"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-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%":"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%":"584"}},"id":3713,"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\/\" 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\/","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\/","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%":"585"}},"id":3714,"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":"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-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%":"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%":"586"}},"id":3715,"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":"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-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%":"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%":"587"}},"id":3716,"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-4\/\" 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-4\/","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-4\/","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%":"588"}},"id":3717,"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-3\/\" 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-3\/","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-3\/","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-08-28T20:25:04.903Z","%_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%":"589"}},"id":3718,"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","%rank_math_analytic_object_id%":"576"}},"id":3705,"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-07-11T15:06:39.379Z","%_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","%rank_math_analytic_object_id%":"579"}},"id":3708,"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\/\" 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\/","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\/","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%":"581"}},"id":3710,"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-2\/\" 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-2\/","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-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 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%":"582"}},"id":3711,"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%":"583"}},"id":3712,"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-07-06T20:35:08.768Z","%_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%":"570"}},"id":3702,"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%":"575"}},"id":3703,"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-07-11T15:06:02.033Z","%_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","%rank_math_analytic_object_id%":"555"}},"id":3693,"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-07-11T15:06:00.515Z","%_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","%rank_math_analytic_object_id%":"556"}},"id":3694,"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-06-26T20:44:00.185Z","%_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%":"567"}},"id":3696,"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-09-17T18:43:24.619Z","%_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","%rank_math_analytic_object_id%":"552"}},"id":3685,"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","%rank_math_analytic_object_id%":"554"}},"id":3687,"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","%rank_math_analytic_object_id%":"550"}},"id":3680,"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\/\" 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\/","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\/","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","%rank_math_analytic_object_id%":"547"}},"id":3676,"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","%rank_math_analytic_object_id%":"549"}},"id":3678,"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%":"536"}},"id":3655,"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-07-08T12:30:34.157Z","%_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%":"467"}},"id":3455,"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\"]"}}