YouthBuild Member Sites - 15 Locations in Illinois

The Illinois YouthBuild Coalition works on behalf of Illinois’ YouthBuild programs to serve young adults across the state. 

YouthBuild programs provide programming that includes integrated education and job skills, training, counseling, leadership development, needs-based stipends, a variety of wrap-around and supportive services and placement in apprenticeships, post-program education or employment, and follow-up services.

During this full-time program, participants are receiving hands-on training at a construction site and attending YouthBuild’s alternative school.

Youthbuild Group

Illinois Locations

{"map_options":{"center_lat":"38.6224687","center_lng":"-90.154585","zoom":1,"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","center_circle_radius":"100","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https://www.youthbuildillinois.org/wp-content/plugins/wp-google-map-gold/assets/images//default_marker.png","draggable":true,"scroll_wheel":"false","gesture":"auto","marker_default_icon":"https://www.youthbuildillinois.org/wp-content/plugins/wp-google-map-gold/assets/images//default_marker.png","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding \">\n    {marker_image}</p>\n<div class=\"fc-itemcontent-padding\">\n<div class=\"fc-itemcontent-padding fc-item-no-padding\">\n<div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">{marker_title}</div>\n<div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\n</p></div>\n</p></div>\n<div class=\"fc-clear\"></div>\n</div>\n","infowindow_geotags_setting":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"{post_link}\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","infowindow_skin":{"name":"aare","type":"infowindow","sourcecode":"<div class=\"fc-item-box fc-item-no-padding \">\r\n    {marker_image}\r\n    <div class=\"fc-itemcontent-padding\">\r\n        <div class=\"fc-itemcontent-padding fc-item-no-padding\">\r\n            <div class=\"fc-item-title fc-item-primary-text-color fc-item-top-space\">{marker_title}</div>\r\n            <div class=\"fc-item-content fc-item-body-text-color\">{marker_address}</div>\r\n        </div>\r\n    </div>\r\n    <div class=\"fc-clear\"></div>\r\n</div>"},"infowindow_post_skin":{"name":"default","type":"post","sourcecode":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"{post_link}\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>"},"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":0,"infowindow_click_change_center":false,"full_screen_control":false,"search_control":true,"zoom_control":true,"map_type_control":false,"street_view_control":false,"locateme_control":false,"mobile_specific":false,"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_zoom_level_mobile":"5"},"ipads":{"map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":true,"infowindow_width":"450px","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":"12","url_filters":false,"doubleclickzoom":true,"current_post_only":false,"bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"450"},"places":[{"source":"post","title":"R3 Development","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/program/r3-development-east-st-louis/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"Coming to a community near you. Enrolling in 2024","address":"East St Louis, IL 62202, USA","location":{"lat":"38.6224687","city":"East St. Louis Township","state":"Illinois","country":"United States","lng":"-90.154585","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/program/r3-development-east-st-louis/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"East St. Louis","post_excerpt":"Coming to a community near you. Enrolling in 2024","post_content":"<p style=\"text-align: center;\">Coming to a community near you. Enrolling in 2024</p>","post_title":"R3 Development","post_link":"https://www.youthbuildillinois.org/program/r3-development-east-st-louis/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Illinois Youth Build Coalition-Emblem\" width=\"600\" height=\"631\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/IllinoisYouthBuildCoalition-Emblem-600x631.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"6","%_edit_lock%":"1710950657:6","%_wp_page_template%":"default","%_wpgmp_location_address%":"East St Louis, IL 62202, USA","%_wpgmp_location_city%":"East St. Louis Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"38.6224687","%_wpgmp_metabox_longitude%":"-90.154585","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%program_banner%":"","%_program_banner%":"field_642b8166eccb1","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"R3 Development officially started in 2015, however, its roots began in 2008 through a local church ministry whose mission was to mentor and disciple youth in East St. Louis, IL. In 2014, that ministry began to consider how it might inspire holistic change in the city of East St. Louis through asset-based housing, workforce and community development efforts, which resulted in the formation of R3. From the beginning the organization had three core objectives: 1) Disciple youth through employment 2) Be reputable landlords for the community and 3) Generate revenue to complement philanthropic giving. As R3 has grown over the years, those core objectives have continued to guide the work, strengthening the organization\u2019s foundation through key strategic partnerships (specifically with local churches), social enterprise efforts and an unwavering commitment to embody empathy, humility, integrity and hope in service to the next generations of leaders in the community. ","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"<strong>R3 Development is non-profit youth workforce training program that exists to mobilize and elevate a pipeline of hopeful youth equipped with the skills needed for success in the working world and the confidence to take control of their futures. With a faith-based foundation focused in the East St. Louis Metro Area, R3\u2019s mission is to empower the youth of the East St. Louis with job opportunities that equip them with the resources and skills necessary for success. Serving youth ages 16\u201324, R3 programming provides opportunities that impact education, occupational skills training, employment service, leadership training, and community service for program participants. R3\u2019s goal is to identify a clear path for advancement from the average starting point of East St. Louis\u2019 youth population. R3 aims to make an impact on the national skilled labor shortage in the construction industry by preparing Metro East youth with skills necessary to competently engage the construction trades. As a United Way Safety-Net, non-profit, the R3 program model seeks to improve and impact economic outcomes, youth employment and leadership development, construction skills and job training, job placement, and affordable housing development.\u00a0</strong>","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<strong>R3 serves male and female students primarily in the East St. Louis District 189, as well as some of the surrounding districts. Our service area is 98%+ African American, targeting youth ages 16-24 within the local school system, as well as young people 16\u201324, who are not within a traditional school or classroom setting, whether due to truancy, justice involvement, teenage parenting or other significant barrier to success . Our student population comes from a historically underserved, low-income, black community. Our students have low academic aptitude (on average) specifically in math and reading comprehension. They also typically have a very small worldview, with little variance in experience.</strong>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"\u2022\tRehabbed over 35 homes in the Metro East\r\n\u2022\tEmployed and training 125+ youth earning $300,000+ in wages from R3\r\n\u2022\tInspired over 1000 youth through workforce development initiatives and training\r\n\u2022\tMobilized 1000s of volunteers to serve along R3 youth to better the East St. Louis community\r\n","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul>\r\n \t<li><strong>Careers Academy Youthbuild (Education focus)</strong></li>\r\n \t<li><strong>Work Academy (Work-readiness focus)</strong></li>\r\n \t<li><strong>2nd Saturday (Servant-leadership &amp; Responsibility focus)</strong></li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathways%":"<ul>\r\n \t<li><strong>Construction (Carpentry &amp; Solar Installation)</strong></li>\r\n \t<li><strong>Real Estate Development &amp; Property Maintenance</strong></li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%success_story%":"","%_success_story%":"field_630d7bd89db9a","%leadership%":"<strong>DAVE KUNTZ</strong>\r\n\r\n<em>Executive Director</em>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>R3 Development NFP</strong>\r\nAddress:\u00a0<a href=\"https://goo.gl/maps/FPxwb9xVdP2R25L1A\">P.O. Box 2197 East St. Louis, IL 62202</a>\r\nOffice: [https://tel:6182151005](618) 215-1005\r\nEmail:\u00a0<a href=\"http://dave@r3development.org/\">dave@r3development.org</a>\r\nWebsite:\u00a0<a href=\"http://r3dev.org/\">R3Dev.org</a>","%_contact_info%":"field_630d7c199db9c","%map_program_thumbnail%":"","%_map_program_thumbnail%":"field_6423ea70ca121","%_wp_old_slug%":"r3-development","%_reorder_term_programs-cat_members%":"15","%_elementor_template_type%":"wp-post","%_elementor_version%":"3.20.1","%_elementor_pro_version%":"3.20.0","%_elementor_data%":"[{\"id\":\"ec8ba52\",\"elType\":\"section\",\"settings\":{\"eae_slider_delay\":\"5000\",\"gradient_color_list\":[{\"eae_animated_gradient_color\":\"#00a6d8\",\"_id\":\"877a252\"},{\"eae_animated_gradient_color\":\"#b800c9\",\"_id\":\"ec0b366\"},{\"eae_animated_gradient_color\":\"#e57600\",\"_id\":\"f74b91b\"}]},\"elements\":[{\"id\":\"b44391a\",\"elType\":\"column\",\"settings\":{\"_column_size\":100,\"_inline_size\":null,\"eae_slider_delay\":\"5000\",\"gradient_color_list\":[{\"eae_animated_gradient_color\":\"#00a6d8\",\"_id\":\"683c20e\"},{\"eae_animated_gradient_color\":\"#b800c9\",\"_id\":\"83c0460\"},{\"eae_animated_gradient_color\":\"#e57600\",\"_id\":\"d0e526e\"}]},\"elements\":[{\"id\":\"ba51ee3\",\"elType\":\"widget\",\"settings\":{\"editor\":\"<p style=\\\"text-align: center;\\\">Coming to a community near you. Enrolling in 2024<\\/p>\"},\"elements\":[],\"widgetType\":\"text-editor\"}],\"isInner\":false}],\"isInner\":false}]","%_elementor_page_assets%":"","%_thumbnail_id%":"2149","%_elementor_controls_usage%":{"text-editor":{"count":1,"control_percent":0,"controls":{"content":{"section_editor":{"editor":1}}}},"column":{"count":1,"control_percent":1,"controls":{"layout":{"layout":{"_inline_size":1}},"style":{"eae_animated_gradient":{"gradient_color_list":1}}}},"section":{"count":1,"control_percent":0,"controls":{"style":{"eae_animated_gradient":{"gradient_color_list":1}}}}},"taxonomy=programs-cat":"Members"}},"id":2392,"infowindow_disable":false},{"source":"post","title":"Sista Girls and Friends","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/program/sista-girls-and-friends/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"Coming to a community near you. Enrolling in 2024","address":"Decatur, IL, USA","location":{"lat":"39.8403147","city":"Decatur","state":"Illinois","country":"United States","lng":"-88.9548001","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/program/sista-girls-and-friends/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Decatur","post_excerpt":"Coming to a community near you. Enrolling in 2024","post_content":"<p style=\"text-align: center;\">Coming to a community near you. Enrolling in 2024</p>","post_title":"Sista Girls and Friends","post_link":"https://www.youthbuildillinois.org/program/sista-girls-and-friends/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Illinois Youth Build Coalition-Emblem\" width=\"600\" height=\"631\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/IllinoisYouthBuildCoalition-Emblem-600x631.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"6","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"Melverta Wilkins founded Sista Girls and Friends in October 2013 in Decatur, Illinois. Melverta Wilkins serves women and girls by sharing her own experiences, educating them, and providing support to each other. Sista Girls and Friends is committed to empowering women and girls, strengthening family dynamics, and educating and training all who seek assistance with our focus designed programs aimed to educate, employ, uplift, and heal our community.  SGAF has started several programs such as a(n) mentoring program, Illinois Works Pre-Apprenticeship, trauma informed behavioral health initiative, and YouthBuild program. The YouthBuild program came under development in September 2022. The YouthBuild program helps young people between the ages of 16-24 develop skills to succeed. The organization also provides resources to help those we serve with career counseling, access to higher education, and financial planning.","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"Sista Girls and Friends YouthBuild Program\u2019s mission statement is \"Empowering young individuals to build brighter futures through education, leadership development, and hands-on vocational training\u201d.","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"Male \u2013 18\r\n\r\nFemale -7\r\n\r\nLow income -25\r\n\r\nHS Dropout \u2013 25\r\n\r\nYouth Offenders \u2013 8\r\n\r\nBasic Skills Deficient -15\r\n\r\nNot Employed at Program Enrollment -19\r\n\r\nJob placement following program completion- Pending program completion.","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"Started program in September 2023 with 12 students in our mental toughness portion of the program. 9 students went on to be in the YouthBuild program. SGAF added several more students to the program. We are currently enrolling for our 2nd cohort. 3 students have received employment through the Springfield Urban League employment program. ","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul>\r\n \t<li>Wrap-around services</li>\r\n \t<li>Therapy sessions</li>\r\n \t<li>Pre-Apprenticeship Certificates</li>\r\n \t<li>Mentorship</li>\r\n \t<li>PMTDI Workforce Certificates</li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathways%":"<ul>\r\n \t<li>Construction and Trades</li>\r\n \t<li>Secondary Vocational school</li>\r\n \t<li>Two/Four Year college opportunities</li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%success_story%":"\u201cRegular schooling wasn\u2019t for me\u201d. Too many people and I just wasn\u2019t focused. When I found out about SGAF YouthBuild program and got enrolled it changed my outlook on how important finishing my education was. Since being in the YouthBuild program I\u2019m comfortable with opening up to others and actually putting in the work to get the job done. I am really looking forward to completing the program so I can continue with my career path that I have set for myself.\u201d- Nick","%_success_story%":"field_630d7bd89db9a","%leadership%":"CEO- Melverta Wilkins\r\n\r\nProgram Director \u2013 Brittoni Wilkins\r\n\r\nOperations Director- Denita Hentz\r\n\r\nCurriculum Director \u2013 Jonathon Boey\r\n\r\nProgram Coordinator- Natasha Young","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong> 500 E Lake Shore. Dr. Decatur, IL 62521\r\n\r\n<strong>Phone:</strong>\r\n\r\n<strong>Email:</strong> <a href=\"mailto:mwilkins.sgaf@gmail.com\"><strong>mwilkins.sgaf@gmail.com</strong></a>\r\n\r\n<strong>Website:</strong> www.sistagirlsandfriends.com\r\n\r\n<strong>Social Media </strong>\r\n\r\n<strong>www.facebook.com/sistagirlsandfriends</strong>","%_contact_info%":"field_630d7c199db9c","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%_edit_lock%":"1711638613:6","%_reorder_term_programs-cat_members%":"12","%_elementor_template_type%":"wp-post","%_elementor_data%":"[{\"id\":\"c31441c\",\"elType\":\"section\",\"settings\":{\"eae_slider_delay\":\"5000\",\"gradient_color_list\":[{\"eae_animated_gradient_color\":\"#00a6d8\",\"_id\":\"8aefc81\"},{\"eae_animated_gradient_color\":\"#b800c9\",\"_id\":\"f8a761f\"},{\"eae_animated_gradient_color\":\"#e57600\",\"_id\":\"96debbc\"}]},\"elements\":[{\"id\":\"181dd5a\",\"elType\":\"column\",\"settings\":{\"_column_size\":100,\"_inline_size\":null,\"eae_slider_delay\":\"5000\",\"gradient_color_list\":[{\"eae_animated_gradient_color\":\"#00a6d8\",\"_id\":\"b726c78\"},{\"eae_animated_gradient_color\":\"#b800c9\",\"_id\":\"57743eb\"},{\"eae_animated_gradient_color\":\"#e57600\",\"_id\":\"454f874\"}]},\"elements\":[{\"id\":\"8c3194a\",\"elType\":\"widget\",\"settings\":{\"editor\":\"<p style=\\\"text-align: center;\\\">Coming to a community near you. Enrolling in 2024<\\/p>\"},\"elements\":[],\"widgetType\":\"text-editor\"}],\"isInner\":false}],\"isInner\":false}]","%_elementor_page_assets%":"","%_elementor_version%":"3.20.1","%_elementor_pro_version%":"3.20.0","%_wpgmp_location_address%":"Decatur, IL, USA","%_wpgmp_location_city%":"Decatur","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"39.8403147","%_wpgmp_metabox_longitude%":"-88.9548001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YBMonogram-OrangeBlue.png","%_map_program_thumbnail%":"field_6423ea70ca121","%_oembed_b82651ba512fa4d577167461d2f23d45%":"{{unknown}}","%_thumbnail_id%":"2149","%program_banner%":"","%_program_banner%":"field_642b8166eccb1","%_elementor_controls_usage%":{"text-editor":{"count":1,"control_percent":0,"controls":{"content":{"section_editor":{"editor":1}}}},"column":{"count":1,"control_percent":1,"controls":{"layout":{"layout":{"_inline_size":1}},"style":{"eae_animated_gradient":{"gradient_color_list":1}}}},"section":{"count":1,"control_percent":0,"controls":{"style":{"eae_animated_gradient":{"gradient_color_list":1}}}}},"taxonomy=programs-cat":"Members"}},"id":1974,"infowindow_disable":false},{"source":"post","title":"Lumity STEMWorks for Construction","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/program/lumity-stemworks-for-construction/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"Founded as the Information Technology Resource Center in 1984, our first mission was to provide IT consulting services with nonprofits to make them more efficient and effective. In 2007, the organization acquired the Nonprofit Finance Center and changed its name to Lumity (illuminate + community). It was our commitment to eliminating the digital divide through starting and supporting 22 community technology centers that led Lumity to adopt its current mission in June 2016.","address":"Chicago, IL, USA","location":{"lat":"41.8781136","city":"Chicago","state":"Illinois","country":"United States","lng":"-87.6297982","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/program/lumity-stemworks-for-construction/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Chicago","post_excerpt":"Founded as the Information Technology Resource Center in 1984, our first mission was to provide IT consulting services with nonprofits to make them more efficient and effective. In 2007, the organization acquired the Nonprofit Finance Center and changed its name to Lumity (illuminate + community). It was our commitment to eliminating the digital divide through starting and supporting 22 community technology centers that led Lumity to adopt its current mission in June 2016.","post_content":"<p style=\"text-align: center;\">Coming to a community near you. Enrolling in 2024</p>","post_title":"Lumity STEMWorks for Construction","post_link":"https://www.youthbuildillinois.org/program/lumity-stemworks-for-construction/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Illinois Youth Build Coalition-Emblem\" width=\"600\" height=\"631\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/IllinoisYouthBuildCoalition-Emblem-600x631.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"Founded as the Information Technology Resource Center in 1984, our first mission was to provide IT consulting services with nonprofits to make them more efficient and effective. In 2007, the organization acquired the Nonprofit Finance Center and changed its name to Lumity (illuminate + community). It was our commitment to eliminating the digital divide through starting and supporting 22 community technology centers that led Lumity to adopt its current mission in June 2016. ","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"<blockquote>\r\n<p style=\"text-align: left;\">Lumity provides teens and young adults from under-resourced communities with transformational experiences that prepare them for lifelong STEM careers.</p>\r\n</blockquote>","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<p style=\"text-align: left;\">Lumity serves approximately 65% Black/African Americans, 30% Hispanic/Latinx, and 5% Asians and mixed races.</p>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"In 2023, Lumity was awarded the U.S. Department of Labor YouthBuild grant to launch our YouthBuild Proviso Township program in Maywood, Illinois with 45 young adults, and became a member of the Illinois YouthBuild Coalition and a YouthBuild USA Provisional Affiliate.","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"&nbsp;\r\n<ul>\r\n \t<li><b><i>STEM Career Prep</i></b>\u00a0is a comprehensive four-year program, embedded in partner high schools, with the goals of academic achievement, graduation and the pursuit of post-graduation STEM pathways. In its fourth year, we are seeing all students improve their skills necessary for STEM careers.</li>\r\n \t<li><b><i>STEMWorks</i></b><b>\u00a0</b>is\u00a0job development and placement program specifically for Chicagoland\u2019s recent graduates without a plan for college or careers. STEMWorks changes their futures by offering a path to high-quality, entry-level STEM jobs with long-term career opportunities and ongoing supports. 85% of participants successfully complete the program, and 70% step into well-paying STEM jobs, with advancement opportunities. Our three STEMWorks programs are:</li>\r\n \t<li>\u00b7<b><i>Illinois Works Pre-Apprenticeship</i></b>\u00a0is designed for youth who are 18 or older who have their high school diploma or GED who want to enter the construction industry. Participants obtain employment skills, NCCER, CPR/First Aid and OSHA-10 certifications, and tutoring to apply to union Apprenticeships.</li>\r\n \t<li>\u00b7<b><i>YouthBuild Proviso Township</i></b><i>\u00a0</i>helps youth ages 17-24 to obtain their GED while learning employability skills through construction training. Like IL Works, youth receive their NCCER, OSHA-10 and CPR/First Aid certifications but the goal is for youth to obtain employment in a career path of interest at the end of the 9-month program.</li>\r\n \t<li>\u00b7<b><i>Illinois Youth Investment Program</i></b>\u00a0(IYIP) is an intensive STEM-related job training and placement program. Over the years, we have successfully trained and prepared over 150 teenagers and young adults for employment in STEM, trades, and other high-growth industries. Participants in our program have obtained various certifications, including NCCER: Basic Construction Skills, Forklift, Flagger, Phlebotomy, CNA, CPR/First Aid, EKG Technician, CDL and more! They have also engaged in soft skills training, covering critical thinking, problem-solving, teamwork, grit, and perseverance.</li>\r\n \t<li>\u00b7<b>In-class, interactive lessons</b>\u00a0that engage youth in learning STEM skills and professional competencies, including social-emotional skills.</li>\r\n \t<li>\u00b7<b>Real World Projects/One Day Challenges</b>, during which teens apply and develop STEM professional skills by working collaboratively with corporate mentors to identify a\u00a0 \u00a0 \u00a0community challenge, design a tech-based solution and pitch their ideas to business leaders.</li>\r\n \t<li>\u00b7<b>Career Networking via STEM Talks and Corporate Visits</b> in which corporate mentors, with similar backgrounds as our students, model navigating college and careers, and\u00a0 \u00a0 \u00a0introduce youth to the workplace.</li>\r\n \t<li>\u00b7\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<b>Homework Help/Tutoring\u00a0</b>so youth have the skills to pursue STEM opportunities.</li>\r\n \t<li>\u00b7\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<b>Career Experiences\u00a0</b>through apprenticeships, internships and, for some programs, job placement with ongoing Lumity coaching.</li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathways%":"<ul>\r\n \t<li>Trades</li>\r\n \t<li>Healthcare</li>\r\n \t<li>IT</li>\r\n \t<li>Manufacturing</li>\r\n \t<li>Transportation &amp; Logistics Industries.</li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%success_story%":"","%_success_story%":"field_630d7bd89db9a","%leadership%":"Executive Director-\u00a0<a href=\"mailto:kkennedy@lumity.org\" data-linkindex=\"0\"><span class=\"markcu48yp0yz\" data-markjs=\"true\" data-ogac=\"\" data-ogab=\"\" data-ogsc=\"\" data-ogsb=\"\">Kara</span>\u00a0Kennedy</a>\r\n\r\nChief Schools &amp; Strategy-\u00a0<a href=\"mailto:mhurley@lumity.org\" data-linkindex=\"1\">Michael Hurley</a>\r\n\r\nOperations Director-\u00a0<a href=\"mailto:csaucedo@lumity.org\" data-linkindex=\"2\">Cynthia Saucedo</a>\r\n\r\nOurtreach Director-\u00a0<a href=\"mailto:aousley@lumity.org\" data-linkindex=\"3\">Asia Ousley</a>\r\n\r\nYouthBuild Proviso Township Program Lead-\u00a0<a href=\"mailto:sballard@lumity.org\" data-linkindex=\"4\">Steven Ballard</a>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"Chicago Office\r\n<p data-event-added=\"1\"><span class=\"HQEo7\" tabindex=\"0\" role=\"link\" data-markjs=\"true\">1132 S. Wabash Ave., Chicago, IL 60605-2326</span></p>\r\n(312) 372-4872","%_contact_info%":"field_630d7c199db9c","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%_edit_lock%":"1710475486:1","%_reorder_term_programs-cat_members%":"13","%_elementor_template_type%":"wp-post","%_elementor_version%":"3.20.1","%_elementor_pro_version%":"3.20.0","%_elementor_data%":"[{\"id\":\"6261f41\",\"elType\":\"section\",\"settings\":{\"eae_slider_delay\":\"5000\",\"gradient_color_list\":[{\"eae_animated_gradient_color\":\"#00a6d8\",\"_id\":\"8aefc81\"},{\"eae_animated_gradient_color\":\"#b800c9\",\"_id\":\"f8a761f\"},{\"eae_animated_gradient_color\":\"#e57600\",\"_id\":\"96debbc\"}]},\"elements\":[{\"id\":\"7ecd984\",\"elType\":\"column\",\"settings\":{\"_column_size\":100,\"_inline_size\":null,\"eae_slider_delay\":\"5000\",\"gradient_color_list\":[{\"eae_animated_gradient_color\":\"#00a6d8\",\"_id\":\"b726c78\"},{\"eae_animated_gradient_color\":\"#b800c9\",\"_id\":\"57743eb\"},{\"eae_animated_gradient_color\":\"#e57600\",\"_id\":\"454f874\"}]},\"elements\":[{\"id\":\"17b6a81\",\"elType\":\"widget\",\"settings\":{\"editor\":\"<p style=\\\"text-align: center;\\\">Coming to a community near you. Enrolling in 2024<\\/p>\"},\"elements\":[],\"widgetType\":\"text-editor\"}],\"isInner\":false}],\"isInner\":false}]","%_elementor_page_assets%":"","%_wpgmp_location_address%":"Chicago, IL, USA","%_wpgmp_location_city%":"Chicago","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"41.8781136","%_wpgmp_metabox_longitude%":"-87.6297982","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_thumbnail_id%":"2149","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YBMonogram-OrangeBlue.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"2459","%_program_banner%":"field_642b8166eccb1","%_elementor_controls_usage%":{"text-editor":{"count":1,"control_percent":0,"controls":{"content":{"section_editor":{"editor":1}}}},"column":{"count":1,"control_percent":1,"controls":{"layout":{"layout":{"_inline_size":1}},"style":{"eae_animated_gradient":{"gradient_color_list":1}}}},"section":{"count":1,"control_percent":0,"controls":{"style":{"eae_animated_gradient":{"gradient_color_list":1}}}}},"taxonomy=programs-cat":"Members"}},"id":1972,"infowindow_disable":false},{"source":"post","title":"Youth Conservation Corps, Inc","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/programs/youth-conservation-corps-inc/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"YCC started as part of the Lake County Forest Preserves in 1974 with a  summer youth forestry conservation program. In 1994, YCC split from the Forest Preserves  to become an independent 501c3 nonprofit.","address":"1020 W Greenwood Ave, Waukegan, IL 60087, USA","location":{"lat":"42.38492919999999","city":"Waukegan Township","state":"Illinois","country":"United States","lng":"-87.84369","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/programs/youth-conservation-corps-inc/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Waukegan","post_excerpt":"YCC started as part of the Lake County Forest Preserves in 1974 with a  summer youth forestry conservation program. In 1994, YCC split from the Forest Preserves  to become an independent 501c3 nonprofit.","post_content":"","post_title":"Youth Conservation Corps, Inc","post_link":"https://www.youthbuildillinois.org/programs/youth-conservation-corps-inc/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"YouthBuild Waukegan-Emblem\" width=\"600\" height=\"644\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildWaukegan-Emblem-600x644.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1710473707:1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"YCC started as part of the Lake County Forest Preserves in 1974 with a  summer youth forestry conservation program. In 1994, YCC split from the Forest Preserves  to become an independent 501c3 nonprofit. In 2001, YCC expanded to offer programs  to opportunity youth. Since its inception, YCC has served over 1750 young adults  throughout Lake County. \r\n\r\n","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"\u2192 YCC Mission Statement: YCC empowers and mentors young adults to succeed through education and training in life skills, career pathways, and environmental stewardship.\r\n\u2192 YCC Vision Statement: Every young adult has a pathway to success. YCC Core Values: Accept others, keep it real, give respect, honor your commitments, be compassionate, show up with effort, build trust, be active in your community.","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<b><i>\u00a0</i></b><span style=\"font-weight: 400;\">YouthBuild members are ages 16 - 24 and primarily from\u00a0 Waukegan, Zion, and North Chicago. Summer Program members come from\u00a0 communities throughout Lake County. 89% are from low-income families Ethnicity:\u00a0 <strong>Hispanic/Latino</strong> - 58.7%; <strong>African American</strong> - 23.9%; <strong>White</strong> - 10.7%; <strong>Biracial</strong> - 6.5%\u00a0</span>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"Educational and Placement The last 18 months of Covid have been  challenging. In a typical year, YCC expects 75% to earn a HSD or occupational  certificate before completing the YouthBuild program. In our Graduate program, 80% of  members typically earn their occupational certification. Our team works to place all  students in jobs or college with 60% typically placed within 6-months of program  completion. YCC's Holistic services and supports: YCC has a food pantry, provides one on-one tutoring, transportation support, mental health services, and referrals to other  services like housing or childcare if needed. ","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul class=\"arrow-list\">\r\n \t<li><span style=\"font-weight: 400;\">Summer Conservation Program: YCC members are young adults who are\u00a0 interested in working outside and pursuing conservation and environmental\u00a0 careers.</span></li>\r\n \t<li><span style=\"font-weight: 400;\">YouthBuild Program: YCC members are opportunity youth \u2013 young adults who\u00a0 are typically not in school or working. YouthBuild members often do not yet have\u00a0 a high school diploma or equivalency.\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Graduate Program: members have a high school diploma and are earning\u00a0 stackable career/occupational credentials in pursuit of high demand career\u00a0 pathways. </span></li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<ul class=\"arrow-list\">\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">IT (CompTIA) </span></li>\r\n</ul>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"Jimmy Ollie \u201cHe handed me a hammer and it changed my life\u201d. Jimmy  came to YCC in 2010. He had been in a gang, served time in jail, was using drugs, had  been shot and stabbed. The mother of his children told him he needed to come to YCC  to change his life, so he did. During his time in the program, he realized that people  believed in him, trusted him and saw a leader in him. He realized he loves construction.  Jimmy told our board members, \u201cOne day the construction Manager handed me a  hammer and it changed my life.\u201d Today, Jimmy a member of the YCC staff and serves  as our Construction Trainer, teaching other young people valuable construction skills and  providing opportunities for a brighter future. \r\n","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul class=\"arrow-list\">\r\n \t<li><span style=\"font-weight: 400;\"><strong>Executive Director:</strong> Jennifer Yonan\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\"><strong>Program Director</strong>: Karen Rios\u00a0</span></li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<b><i>Address: </i></b><a href=\"https://goo.gl/maps/RTMdCPCc8LAR4oom7\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">1020 W. Greenwood Ave., Waukegan, IL 60087\u00a0</span></a>\r\n\r\n<b><i>Phone: </i></b><a href=\"tel:847-623-0900\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">847-623-0900\u00a0</span></a>\r\n\r\n<b><i>Contact Email</i></b><span style=\"font-weight: 400;\">: </span><a href=\"mailto:jyonan@youthconservationcorps.org\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">j</span><span style=\"font-weight: 400;\">yonan@youthconservationcorps.org</span></a>\r\n\r\n<b><i>Website: </i></b><a href=\"https://www.youthconservationcorps.org/\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">https://www.youthconservationcorps.org</span></a>\r\n\r\n<b><i>Social Media:\u00a0\u00a0</i></b>\r\n\r\n<span style=\"font-weight: 400;\">\u2192 </span><span style=\"font-weight: 400;\"><strong>Facebook</strong>: </span><a href=\"https://www.facebook.com/YCCWaukegan/?notif_id=1557775781762 370&amp;notif_t=page_fan\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">https://www.facebook.com/YCCWaukegan/?notif_id=1557775781762</span> <span style=\"font-weight: 400;\">370&amp;notif_t=page_fan</span></a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"12","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"waukegan","%_thumbnail_id%":"2156","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Information Technology (CompTIA) </span></li>\r\n \t<li>Trade</li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%_wpgmp_location_address%":"1020 W Greenwood Ave, Waukegan, IL 60087, USA","%_wpgmp_location_city%":"Waukegan Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"42.38492919999999","%_wpgmp_metabox_longitude%":"-87.84369","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildWaukegan-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"1707","%_program_banner%":"field_642b8166eccb1","%_elementor_template_type%":"wp-post","%_elementor_version%":"3.20.1","%_elementor_pro_version%":"3.20.0","taxonomy=programs-cat":"Members"}},"id":977,"infowindow_disable":false},{"source":"post","title":"YouthBuild Quad Cities","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/youthbuild-quad-cities/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"YouthBuild Quad Cities has been operation since 2003 and has restarted in  2019 after a three-year shutdown due to funding. ","address":"1800 3rd Ave suite 401, Rock Island, IL 61201, USA","location":{"lat":"41.5096536","city":"Rock Island Township","state":"Illinois","country":"United States","lng":"-90.5743652","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/youthbuild-quad-cities/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Rock Island","post_excerpt":"YouthBuild Quad Cities has been operation since 2003 and has restarted in  2019 after a three-year shutdown due to funding. ","post_content":"","post_title":"YouthBuild Quad Cities","post_link":"https://www.youthbuildillinois.org/youthbuild-quad-cities/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"YouthBuild Quad Cities-Emblem\" width=\"600\" height=\"631\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildQuadCities-Emblem-600x631.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1710473573:1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"YouthBuild Quad Cities has been operation since 2003 and has restarted in 2019 after a three-year shutdown due to funding. ","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"YouthBuild Quad Cities is a wide-ranging youth and community development program. YouthBuild addresses several core issues facing our community simultaneously: education, housing, jobs, and leadership development. It uniquely addresses the status of unemployed young men and women who have not finished school and are searching for a productive future. YouthBuild Quad Cities allows young people to serve their communities and build their own future.","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<span style=\"font-weight: 400;\">Currently 9 students 16-18 years old's - 4 African Americans, 2\u00a0 Latinos, and 3 Hispanic of this we have two females and seven males. </span>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"The biggest accomplishments will be the partnerships with the local  agencies and schools. This includes Rock Island High School, Black Hawk Community  College, City of Moline, Arrowhead Academy, Habitat for Humanity of the Quad Cities,  Rock Island Rescue Mission, Illinois-Iowa Center for Independent Living and Project Now  of the Quad Cities. \r\n","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul class=\"arrow-list\">\r\n \t<li><span style=\"font-weight: 400;\">Construction training\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Life Skills\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Career and personal counseling</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Education and Leadership Development\u00a0</span></li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<span style=\"font-weight: 400;\">Completing their high school diploma and GED will lead to the trades\u00a0 for a PR apprenticeship program in the trades.\u00a0</span>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Executive Director/Case Manager:\u00a0 Rufus Greer, Jr.</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Program Director/Construction Manager:\u00a0 Koffi Gbenyo (his last name was spelled incorrectly)</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Assistant to the Director/Bookkeeper:\u00a0 Joni Kampner</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Administrative Assistant:\u00a0 Shelley Neuerburg</span></li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<b><i>Address: </i><a href=\"https://goo.gl/maps/efXt9tc9MyrbgFaU6\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">1800 3</span><span style=\"font-weight: 400;\">rd</span><span style=\"font-weight: 400;\"> Ave., Suite 401, Rock Island, IL 61201</span></a></b>\r\n\r\n<b><i>Phone: </i></b><span style=\"font-weight: 400;\">Office: <a href=\"tel:309-788-0899\" target=\"_blank\" rel=\"noopener\">309-788-0899</a>/Cell: <a href=\"tel:309-532-2656\" target=\"_blank\" rel=\"noopener\">309-532-2656\u00a0</a></span>\r\n\r\n<b><i>Contact Email: </i></b><a href=\"mailto:jrgreer52@icloud.com\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">j</span><span style=\"font-weight: 400;\">rgreer52@icloud.com</span> </a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"11","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"rock-island","%_thumbnail_id%":"2154","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Trade\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Apprenticeship</span></li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%_wpgmp_location_address%":"1800 3rd Ave suite 401, Rock Island, IL 61201, USA","%_wpgmp_location_city%":"Rock Island Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"41.5096536","%_wpgmp_metabox_longitude%":"-90.5743652","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildQuadCities-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"1722","%_program_banner%":"field_642b8166eccb1","%_elementor_template_type%":"wp-post","%_elementor_version%":"3.20.1","%_elementor_pro_version%":"3.20.0","taxonomy=programs-cat":"Members"}},"id":975,"infowindow_disable":false},{"source":"post","title":"YouthBuild Rockford","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/youthbuild-rockford/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"Comprehensive Community Solutions, Inc. (CCS) began in 1992 as a  community-based program founded by a probation officer who felt as though the  system was letting young people down. ","address":"917 S Main St, Rockford, IL 61101, USA","location":{"lat":"42.2633221","city":"Rockford Township","state":"Illinois","country":"United States","lng":"-89.10055890000001","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/youthbuild-rockford/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Rockford","post_excerpt":"Comprehensive Community Solutions, Inc. (CCS) began in 1992 as a  community-based program founded by a probation officer who felt as though the  system was letting young people down. ","post_content":"","post_title":"YouthBuild Rockford","post_link":"https://www.youthbuildillinois.org/youthbuild-rockford/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"YouthBuild Rockford-Emblem\" width=\"600\" height=\"644\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildRockford-Emblem-600x644.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1710473563:1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"Comprehensive Community Solutions, Inc. (CCS) began in 1992 as a  community-based program founded by a probation officer who felt as though the  system was letting young people down. Starting out providing services to youth in the  criminal justice system, CCS quickly morphed into a multi-faceted nonprofit organization  with a mission that includes three major areas: Workforce Development; Affordable  Housing Development, and meaningful Community Engagement. Through this mission,  CCS has served out-of-school and at-risk youth through its established Pre-Apprenticeship  employment program called YouthBuild Rockford since 1994. \r\n\r\n\r\n","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"Comprehensive Community Solutions, Inc. is an organization that drives fundamental transformation of neighborhoods, communities, and the circumstances of those who reside there through facilitation of workforce development that leads to a sustainable wage, meaningful community engagement and affordable housing.\r\n\r\n<strong>Partnership</strong>\u2014 Participating in the collective efforts of the entire community through communication, collaboration, and teamwork to drive fundamental transformation.\r\n\r\n<strong>Respect</strong>\u2014 Showing value for our customers, partners, and each other by acknowledging the potential to achieve and maintaining an attitude of empathy.\r\n\r\n<strong>Accountability</strong>\u2014 Owning our ability to determine our outcomes and accepting our responsibility to be impactful.\r\n\r\n<strong>Intentional Growth</strong>\u2014 Being strategic about our choices, innovative in our efforts, and mission-driven in actions.\r\n\r\n<strong> Curiosity</strong>\u2014 Driven by a desire to better understand our customers, partners, and each other so that we are open minded in our service.\r\n\r\n<strong>Leadership &amp; Service</strong>\u2014 Taking an active role in developing, implementing, and sustaining a solution(s) to opportunities within our reach.","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<span style=\"font-weight: 400;\">CCS has traditionally served youth 16-24, who have significant\u00a0 educational or employment deficits and who meet the Department of Labor\u2019s eligibility\u00a0 criteria, especially those who are low-income, high school dropouts (at least 75% over a\u00a0 26 yr. period), youth offenders, unemployed and live in the target area of Rockford, IL.\u00a0</span>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"CCS\u2019s YouthBuild Rockford program has enrolled over 1,055 at-risk  youth, exceeding its enrollment rate at 106%, due to receiving over 6,000 applications  over the years. The youth enrolled in YouthBuild Rockford have been 79% minority, 88%  low-income, 53% have had criminal records, and 97% have been high school dropouts.  80% of the youth enrolled in YouthBuild Rockford were placed in employment and/or post-secondary education by the time the completed the program and 69% retained that placement for at least a year. \r\n","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul class=\"arrow-list\">\r\n \t<li><strong>YouthBuild Rockford</strong>: YouthBuild is a unique program serving out of school youth\u00a0 ages 16-24 who are from low-income communities, have left school and are\u00a0 unemployed. It provides academic education, vocational skills training, personal\u00a0 counseling, positive peer support, leadership development, job placement and\u00a0 follow-up support. Young people spend half their time in academic programming\u00a0 and the other half learning skills in construction. Participants build or rehabilitate\u00a0 housing for low-income families and have produced 45 units of affordable\u00a0 housing in Rockford since the program began. Since 1994, YouthBuild Rockford\u00a0 has seen over 6,000 youth apply, and has served more than 1,000 young people.\u00a0 80% of program completers have been placed in jobs or educational programs,\u00a0 and youth have completed over 510,000 hours of community service. YouthBuild.</li>\r\n \t<li><span style=\"font-weight: 400;\"><strong>USA AmeriCorps</strong>: AmeriCorps is a national service movement that engages\u00a0 Americans of all ages in a domestic \u201cPeace Corps\u201d to get things done in our\u00a0 local communities. As part of a national service movement overseen by the\u00a0 Corporation for National Service and YouthBuild USA, AmeriCorps members\u00a0 commit to a term of community service and upon completion they earn an\u00a0 education award which can be used to pay for college or vocational training.\u00a0 CCS has operated this program since 1996, and since then member have\u00a0 completed over 510,000 hours of community service.\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">YouthBuild USA Mentoring: YouthBuild USA Mentoring is a national movement\u00a0 designed to get professional connected to YouthBuild participants to be career\u00a0 coaches and advocates that help them stay focused and committed to their\u00a0 goals. CCS has successfully operated this program since 2010.\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\"><strong>RockForWork</strong>: The Illinois Youth Investment Program (IYIP), formerly known as\u00a0 Community Youth Employment Program, is a multi-faceted approach to youth\u00a0 employment that invests in the future of Illinois\u2019 at-risk transition-age youth (16- 24).\u00a0 This approach to youth employment accounts for the youth\u2019s employment\u00a0 barriers as well as the physical, emotional, social, and mental health needs while\u00a0 helping them to secure and sustain long-term and/or career employment\u00a0 thereby ensuring a greater likelihood of success and self-sufficiency. This program\u00a0 was established in 2020 at CCS.\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\"><strong>ALPHA</strong>: ALPHA is a youth development/violence prevention program that is\u00a0 funded by the Illinois Restore, Reinvest, and Renew (R3) program, which was\u00a0 created as a key equity element of the Cannabis Regulation and Tax Act (CRTA).\u00a0 ALPHA aligns with the City of Rockford, Alignment Rockford, the Rockford Park\u00a0 District, and Rockford Public Schools Live, Learn, Play Universal Goal number 4:\u00a0 Increase the district graduation rate and freshman on-track rate to 75% by 2024.\u00a0 This goal of ALPHA is achieved by helping youth graduate high school by\u00a0 providing them with a safe and friendly learning environment that provides help\u00a0 with tutoring and homework, builds character, enhances positive thinking and\u00a0 self-respect while they learn discipline and dedication, self-control, problem\u00a0 solving, strategic thinking, and proper exercise and nutrition to build a healthy\u00a0 lifestyle and be excited about school. This program was established in 2021 at\u00a0 CCS.\u00a0</span></li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<ul class=\"arrow-list\">\r\n \t<li><span style=\"font-weight: 400;\">Construction</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Welding\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">CNA\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Culinary Arts (Coming Soon)</span></li>\r\n</ul>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"CCS had a young Hispanic male enroll in our YouthBuild Rockford  program in 2020 who was a court involved youth. He was a high school dropout and not  sure what his future was when he first enrolled. This young man graduated from the  YouthBuild Rockford program and became an AmeriCorps member at the agency  acting as an apprentice in our construction department in 2021. Today he is a full  apprentice employed by CCS as a Construction assistant in our YouthBuild Rockford  program. To date he has built two units of low-income housing, been responsible for  maintaining two maintenance contracts with housing partners and continues to build his  skills working side by side with Journeymen Carpenters. ","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul>\r\n \t<li style=\"list-style-type: none;\">\r\n<ul>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"4\"><span style=\"font-weight: 400;\">Executive Director/CEO: William Chatman\u00a0</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"4\"><span style=\"font-weight: 400;\">Director of Programs: Joshua Patterson\u00a0</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"4\"><span style=\"font-weight: 400;\">Director of Workforce Development: Claudia Consuelos\u00a0</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"4\"><span style=\"font-weight: 400;\">Fiscal Manager: Pam Arnold</span></li>\r\n</ul>\r\n</li>\r\n</ul>\r\n&nbsp;","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<b><i>Address: </i></b><a href=\"https://goo.gl/maps/ZxGXi2XUb7xpBAWLA\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">917 S. Main St. Rockford, IL 61101\u00a0</span></a>\r\n\r\n<b><i>Phone: </i></b><span style=\"font-weight: 400;\"><a href=\"tel:815-963-6236\" target=\"_blank\" rel=\"noopener\">815-963-6236</a>\u00a0</span>\r\n\r\n<b><i>Fax: </i></b><span style=\"font-weight: 400;\">815-963-1002\u00a0</span>\r\n\r\n<b><i>Contact Email: </i></b><a href=\"mailto:ybrkfd@youthbuildrockford.org\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">ybrkfd@youthbuildrockford.org</span></a><span style=\"font-weight: 400;\">\u00a0</span>\r\n\r\n<b><i>Website: </i></b><a href=\"https://comprehensivecommunitysolutions.org/\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">https://comprehensivecommunitysolutions.org/</span> </a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"10","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"rockford","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Welding\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Certified Nurse Assistant (CNA)\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Trade </span></li>\r\n \t<li>Culinary Arts (Coming Soon)</li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%_thumbnail_id%":"2155","%_wpgmp_location_address%":"917 S Main St, Rockford, IL 61101, USA","%_wpgmp_location_city%":"Rockford Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"42.2633221","%_wpgmp_metabox_longitude%":"-89.10055890000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildRockford-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"2093","%_program_banner%":"field_642b8166eccb1","%_elementor_template_type%":"wp-post","%_elementor_version%":"3.20.1","%_elementor_pro_version%":"3.20.0","taxonomy=programs-cat":"Members"}},"id":973,"infowindow_disable":false},{"source":"post","title":"YouthBuild Lake County, Inc.","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/program/youthbuild-lake-county/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"In 2003, we offered our first program to 35 young people as a program run through Daisy\u2019s Resource Center. In 2004 YouthBuild Lake County was incorporated and began offering the YouthBuild Program. ","address":"2303 Kemble Ave, North Chicago, IL 60064, USA","location":{"lat":"42.3173282","city":"Shields Township","state":"Illinois","country":"United States","lng":"-87.85473689999999","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/program/youthbuild-lake-county/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"North Chicago","post_excerpt":"In 2003, we offered our first program to 35 young people as a program run through Daisy\u2019s Resource Center. In 2004 YouthBuild Lake County was incorporated and began offering the YouthBuild Program. ","post_content":"","post_title":"YouthBuild Lake County, Inc.","post_link":"https://www.youthbuildillinois.org/program/youthbuild-lake-county/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"YouthBuild Lake County-Emblem\" width=\"600\" height=\"644\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildLakeCounty-Emblem-600x644.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1710468656:1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"In 2003, we offered our first program to 35 young people as a program run through Daisy\u2019s Resource Center. In 2004 YouthBuild Lake County was incorporated and began offering the YouthBuild Program. That year we served 45 youth. Following YouthBuild USA\u2019s model, we offer education, counseling, leadership, career training, and job placement for underserved youth ages 17-24. Through our 9-month program, youth earn their high school diploma, earn industry-recognized credentials, participate in counseling and wellness services and learn job readiness skills. In 2022, YouthBuild Lake County expanded its programming with the addition of a 12-week Pre-Apprentice Program, which allows any Illinois resident ages 18 and over a chance to begin a successful career in the construction trades. Both of our programs also teach the value of giving back to the community in which you live. Since opening our doors, we have served over 1,000 youth who have provided well over 100,000 hours of community service through their construction work and volunteering.","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"<span style=\"font-weight: 400;\">Our mission is to provide underserved young adults with the education, training, and life skills necessary to become gainfully employed and build a better future. At YouthBuild Lake County, we believe that every young person has the power to succeed and create a better life for themselves and their families with access to the right resources and support system. We offer free programs for underserved youth in Lake County to obtain their high school diploma, earn industry-recognized credentials and certifications, develop career readiness skills, prepare to enter apprenticeships in the construction trades, and complete hands-on work experience so they can move into careers, college, or vocational schools.</span>","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<span style=\"font-weight: 400;\">For our YouthBuild Program, members must be 17-24 years old and a resident of Lake County. They also need to be one of the following to be eligible for program enrollment: low-income status, youth or adult offender status, disability, incarcerated parent, migrant youth status, or in/aged out of the foster care system. For our Pre-Apprentice Program, trainees must be Illinois residents over the age of 18 with a passion for the construction trades. They also must be interested in entering a Department of Labor-approved apprenticeship after graduating from the program.</span>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"LCCC\u2019s Adult Education Department serves people through multiple State and Federal Initiatives.\r\n\r\n\u2192 The following initiatives are included in our daily programming: YouthBuild (Construction, Computer Careers, and TDL), Certified Nursing Assistants Training (CNA), English as a Second Language, High School Equivalency Instruction, Project Read (tutoring services), Family Literacy (which includes free onsite childcare assistance), and AmeriCorps.\r\n","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"Programs Offered: YouthBuild Lake County currently offers two programs: our YouthBuild Program and our Pre-Apprentice Program.\r\n\r\n\u2192 Our YouthBuild Program includes: Accredited high school diploma attainment, College, and career readiness training (mock interviews, resume building, FAFSA support), hands-on work experience, industry-recognized credentials and certifications, transitional assistance (career, college, or vocational school), and wrap around supportive services (mental health support, counseling, nutrition groups, childcare assistance).\r\n\u2192 Our Pre-Apprentice Program includes: On-site construction experience, industry-recognized credentials, and certifications (OSHA, NCCER, CPR), preparation for apprentice programs (tutoring services, financial assistance), transitional assistance (career and union apprenticeship), and wrap around supportive services (childcare assistance, transportation assistance).","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<ul class=\"arrow-list\">\r\n \t<li>Construction (Carpentry, Welding, Solar Installation)</li>\r\n \t<li>Transportation, Distribution, and Logistics (TDL)</li>\r\n \t<li>Computer Careers (Microsoft Suite, Information Technology, Webpage Design)</li>\r\n \t<li>Certified Nurse Assistant (CNA</li>\r\n</ul>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"Alan Buenrostro, a 2017 YouthBuild graduate, wanted to create a better future not only for himself, but for the most important person in his life\u2013\u2013 his one-year-old son. Alan fell in love with YouthBuild\u2019s program, and, after gaining hands-on experience at the job sites, found his passion for construction. Alan now works full time as a Journeyman Union Carpenter for Blinderman Construction, a YouthBuild employer partner, building a better future for him and his son every day.","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul class=\"arrow-list\">\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Tameka Wilson \u2013 Executive Director</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Carlos Argueta \u2013 Senior Director of Programs</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Jennifer Olson \u2013 Senior Director of Finance &amp; Development</span></li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong> <a href=\"https://goo.gl/maps/RHkoF3vUobURUhaz5\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">2303 Kemble Ave, North Chicago IL 60064</span></a>\r\n\r\n<strong>Phone: <a href=\"tel:847-473-3483\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">847-473-3483</span></a></strong>\r\n\r\n<strong>Contact Email:</strong> <a href=\"mailto:info@yblc.org\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">info@yblc.org</span></a>\r\n\r\n<strong>Website:</strong> <a href=\"http://www.yblc.org\" target=\"_blank\" rel=\"noopener\"><span style=\"font-weight: 400;\">www.yblc.org</span></a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"9","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"north-chicago","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Automotive\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">HVAC\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Healthcare\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Information Technology\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Trade\u00a0</span></li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%_thumbnail_id%":"2152","%_wpgmp_location_address%":"2303 Kemble Ave, North Chicago, IL 60064, USA","%_wpgmp_location_city%":"Shields Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"42.3173282","%_wpgmp_metabox_longitude%":"-87.85473689999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildLakeCounty-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"1463","%_program_banner%":"field_642b8166eccb1","taxonomy=programs-cat":"Members"}},"id":971,"infowindow_disable":false},{"source":"post","title":"Building Futures YouthBuild","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/building-futures-youthbuild/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"Lewis and Clark Community College (LCCC) has been a staple in the community for high school equivalency and work force training for many years. ","address":"5800 Godfrey Rd, Godfrey, IL 62035, USA","location":{"lat":"38.9512551","city":"Godfrey Township","state":"Illinois","country":"United States","lng":"-90.19260949999999","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/building-futures-youthbuild/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Godfrey","post_excerpt":"Lewis and Clark Community College (LCCC) has been a staple in the community for high school equivalency and work force training for many years. ","post_content":"","post_title":"Building Futures YouthBuild","post_link":"https://www.youthbuildillinois.org/building-futures-youthbuild/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Building Futures YouthBuild-Emblem\" width=\"600\" height=\"614\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/BuildingFuturesYouthBuild-Emblem-600x614.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_seopress_analysis_data%":{"title":"Building Futures YouthBuild - IL YouthBuild","link_preview":"https://www.youthbuildillinois.org/building-futures-youthbuild/?no_admin_bar=1&preview=true","og_title":{"count":1,"values":["Building Futures YouthBuild"]},"og_desc":{"count":1,"values":["Lewis and Clark Community College (LCCC) has been a staple in the community for high school equivalency and work force training for many years."]},"og_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/BuildingFuturesYouthBuild-Emblem.png"]},"og_url":{"count":1,"values":["https://www.youthbuildillinois.org/building-futures-youthbuild/"],"host":"www.youthbuildillinois.org"},"og_site_name":{"count":1,"values":["IL YouthBuild"]},"tw_title":{"count":1,"values":["Building Futures YouthBuild"]},"tw_desc":{"count":1,"values":["Lewis and Clark Community College (LCCC) has been a staple in the community for high school equivalency and work force training for many years."]},"tw_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/BuildingFuturesYouthBuild-Emblem-1200x1227.png"]},"canonical":"https://www.youthbuildillinois.org/building-futures-youthbuild/","all_canonical":["https://www.youthbuildillinois.org/building-futures-youthbuild/"],"h1":{"nomatches":{"count":1}},"img":{"images":{"without_alt":[],"with_alt":[]}},"meta_robots":[["index, follow"]],"outbound_links":{"4":{"https://goo.gl/maps/PyJ3hPdFtbnvhyx69":"5800 Godfrey Rd. Godfrey, Il 62035"},"7":{"https://www.lc.edu/adulted/":"https://www.lc.edu/adulted/"},"8":{"https://www.lc.edu/Youthbuild/":"https://www.lc.edu/Youthbuild/"},"9":{"https://goo.gl/maps/LrzA84xcg1L6or7x5":"\r\n1111 South Alpine Rd., Suite 602\r\nRockford, IL 61108\r\n\r\n"},"12":{"https://www.facebook.com/IllinoisYBC/ ":""},"13":{"https://www.linkedin.com/company/illinois-youthbuild-coalition-inc.":""},"14":{"https://www.cyberoptik.net/":""}},"words_counter":272,"words_counter_unique":176},"%_edit_last%":"1","%_edit_lock%":"1685556470:1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"Lewis and Clark Community College (LCCC) has been a staple in the community for high school equivalency and work force training for many years. LCCC\u2019s Building Futures YouthBuild began serving youth through the YouthBuild initiative in 2009 and our program has grown to include pathways to employment in industry sectors such as computer careers; Transportation, Distribution, and Logistics (TDL), and construction. We are committed to the most fundamental principles of human dignity, equality of opportunity and academic freedom. That\u2019s why our motto is \u201cempowering people.\u201d","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"We are committed to the most fundamental principles of human dignity, equality of opportunity and academic freedom. That\u2019s why our motto is \u201cempowering people.\u201d","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"16\u201324-Year-Old Out of School Youth","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"LCCC\u2019s Adult Education Department serves people through multiple State and Federal Initiatives.\r\n\r\n\u2192 The following initiatives are included in our daily programming: YouthBuild (Construction, Computer Careers, and TDL), Certified Nursing Assistants Training (CNA), English as a Second Language, High School Equivalency Instruction, Project Read (tutoring services), Family Literacy (which includes free onsite childcare assistance), and AmeriCorps.","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<ul class=\"arrow-list\">\r\n \t<li>Construction (Carpentry, Welding, Solar Installation)</li>\r\n \t<li>Transportation, Distribution, and Logistics (TDL)</li>\r\n \t<li>Computer Careers (Microsoft Suite, Information Technology, Webpage Design)</li>\r\n \t<li>Certified Nurse Assistant (CNA</li>\r\n</ul>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"LaNiece May, a 2021 YouthBuild Graduate, completed her HBI PACT certificate in Carpentry and also completed Solar Installation Training. She became employed in January of 2022 at Straight-up Solar as a Solar Installation Technician and LOVES her new career!","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul class=\"arrow-list\">\r\n \t<li>Associate Dean of Adult Education \u2013 Valorie Harris</li>\r\n \t<li>Director, Pathway Resource Development- Sabrina Davis</li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong>\u00a0<a href=\"https://goo.gl/maps/PyJ3hPdFtbnvhyx69\" target=\"_blank\" rel=\"noopener\">5800 Godfrey Rd. Godfrey, Il 62035</a>\r\n\r\n<strong>Phone:\u00a0</strong><a href=\"tel:618-468-4141\" target=\"_blank\" rel=\"noopener\">618-468-4141</a>\r\n\r\n<strong>Contact Email:</strong>\u00a0<a href=\"mailto:sdavis@lc.edu\" target=\"_blank\" rel=\"noopener\">sdavis@lc.edu\u00a0</a>\r\n\r\n<strong>Website:</strong>\r\n<ul>\r\n \t<li><a href=\"https://www.lc.edu/adulted/\" target=\"_blank\" rel=\"noopener\">https://www.lc.edu/adulted/</a></li>\r\n \t<li><a href=\"https://www.lc.edu/Youthbuild/\" target=\"_blank\" rel=\"noopener\">https://www.lc.edu/Youthbuild/</a></li>\r\n</ul>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"8","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"godfrey","%_thumbnail_id%":"2146","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction (Carpentry, Welding, Solar Installation)\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Transportation, Distribution, and Logistics (TDL)\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Computer Careers (Microsoft Suite, Information Technology, Webpage\u00a0 Design)\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Certified Nurse Assistant (CNA)\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Trade\u00a0</span></li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%_wpgmp_location_address%":"5800 Godfrey Rd, Godfrey, IL 62035, USA","%_wpgmp_location_city%":"Godfrey Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"38.9512551","%_wpgmp_metabox_longitude%":"-90.19260949999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/BuildingFuturesYouthBuild-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"1723","%_program_banner%":"field_642b8166eccb1","taxonomy=programs-cat":"Members"}},"id":969,"infowindow_disable":false},{"source":"post","title":"Bethel Family Resources Center","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/bethel-family-resources-center/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"Bethel Family Resource Center was envisioned 45 years ago by Reverend John H. Rice, former Pastor of St. Bethel Baptist Church. ","address":"1250 Portland Ave, Chicago Heights, IL 60411, USA","location":{"lat":"41.5081786","city":"Bloom Township","state":"Illinois","country":"United States","lng":"-87.6236181","onclick_action":"post","redirect_permalink":"https://www.youthbuildillinois.org/bethel-family-resources-center/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Chicago Heights","post_excerpt":"Bethel Family Resource Center was envisioned 45 years ago by Reverend John H. Rice, former Pastor of St. Bethel Baptist Church. ","post_content":"","post_title":"Bethel Family Resources Center","post_link":"https://www.youthbuildillinois.org/bethel-family-resources-center/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bethel YouthBuild-Emblem\" width=\"600\" height=\"631\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/BethelYouthBuild-Emblem-600x631.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1685556470:1","%_seopress_analysis_data%":{"title":"Bethel Family Resources Center - IL YouthBuild","link_preview":"https://www.youthbuildillinois.org/bethel-family-resources-center/?no_admin_bar=1&preview=true","og_title":{"count":1,"values":["Bethel Family Resources Center"]},"og_desc":{"count":1,"values":["Bethel Family Resource Center was envisioned 45 years ago by Reverend John H. Rice, former Pastor of St. Bethel Baptist Church."]},"og_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/BethelYouthBuild-Emblem.png"]},"og_url":{"count":1,"values":["https://www.youthbuildillinois.org/bethel-family-resources-center/"],"host":"www.youthbuildillinois.org"},"og_site_name":{"count":1,"values":["IL YouthBuild"]},"tw_title":{"count":1,"values":["Bethel Family Resources Center"]},"tw_desc":{"count":1,"values":["Bethel Family Resource Center was envisioned 45 years ago by Reverend John H. Rice, former Pastor of St. Bethel Baptist Church."]},"tw_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/BethelYouthBuild-Emblem-1200x1262.png"]},"canonical":"https://www.youthbuildillinois.org/bethel-family-resources-center/","all_canonical":["https://www.youthbuildillinois.org/bethel-family-resources-center/"],"h1":{"nomatches":{"count":1}},"img":{"images":{"without_alt":[],"with_alt":[]}},"meta_robots":[["index, follow"]],"outbound_links":{"4":{"https://goo.gl/maps/RkZtaAwvXuSsodjV7":"1250 Portland Avenue, Chicago, Illinois 60411"},"7":{"http://www.bethelfacility.org/":"www.bethelfacility.org\u00a0"},"8":{"https://goo.gl/maps/LrzA84xcg1L6or7x5":"\r\n1111 South Alpine Rd., Suite 602\r\nRockford, IL 61108\r\n\r\n"},"11":{"https://www.facebook.com/IllinoisYBC/ ":""},"12":{"https://www.linkedin.com/company/illinois-youthbuild-coalition-inc.":""},"13":{"https://www.cyberoptik.net/":""}},"words_counter":228,"words_counter_unique":159},"%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"Bethel Family Resource Center was envisioned 45 years ago by Reverend John H. Rice, former Pastor of St. Bethel Baptist Church. After years of watching the area, he grew up in deteriorate, he decided that a local community center was needed to serve as a headquarter for community restoration. Bethel Community Facility was created out of this initiative. The organization\u2019s name was later changed to Bethel Family Resource Center. It is now under the leadership of Pastor Lawrence J. Blackful and still serving the community.","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"The motto is \u201cWe Believe: Prayers, Plans, Patience, and Perseverance Produce Results\u201d","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<ul class=\"arrow-list\">\r\n \t<li>90% African American</li>\r\n \t<li>10% Latino</li>\r\n \t<li>Low Income</li>\r\n</ul>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"Participants have entered into the solar panel installation field; some participants have been accepted into the carpenter\u2019s apprenticeship, and many have career-based employment.","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul class=\"arrow-list\">\r\n \t<li>YouthBuild</li>\r\n \t<li>Performing Arts &amp; Camp</li>\r\n \t<li>Shelter for the Homeless</li>\r\n \t<li>Workforce Innovation Opportunity Act Program</li>\r\n \t<li>Construction</li>\r\n \t<li>CNA/Nursing</li>\r\n \t<li>Arts</li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<ul class=\"arrow-list\">\r\n \t<li>Construction</li>\r\n \t<li>CNA/Nursing</li>\r\n \t<li>Arts</li>\r\n</ul>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"Amari McKay completed the program in 2019. She applied and received employment to a solar company. After working in the industry for several years, she is now a lead installer for a solar installation company in Des Moines, Iowa. She earns $32 per hour.","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul class=\"arrow-list\">\r\n \t<li>CEO: Lawrence J. Blackful</li>\r\n \t<li>Grant Manager &amp; Director of Programs: Tonii Harris</li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong>\u00a0<a href=\"https://goo.gl/maps/RkZtaAwvXuSsodjV7\" target=\"_blank\" rel=\"noopener\">1250 Portland Avenue, Chicago, Illinois 60411</a>\r\n\r\n<strong>Phone:\u00a0</strong><a href=\"tel:708-758-5585\" target=\"_blank\" rel=\"noopener\">708-758-5585</a>\r\n\r\n<strong>Contact Email:</strong>\u00a0:\u00a0<a href=\"mailto:rfleming@bethelfacility.org\" target=\"_blank\" rel=\"noopener\">rfleming@bethelfacility.org</a>\r\n\r\n<strong>Website:\u00a0</strong><a href=\"http://www.bethelfacility.org/\" target=\"_blank\" rel=\"noopener\">www.bethelfacility.org\u00a0</a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"7","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"chicago-heights","%_thumbnail_id%":"2145","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Certified Nursing Assistant\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Nursing\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Arts\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Trade\u00a0 </span></li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%_wpgmp_location_address%":"1250 Portland Ave, Chicago Heights, IL 60411, USA","%_wpgmp_location_city%":"Bloom Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"41.5081786","%_wpgmp_metabox_longitude%":"-87.6236181","%_wpgmp_metabox_location_redirect%":"post","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/BethelYouthBuild-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_thumb_copy%":"2145","%_program_thumb_copy%":"field_642b7ccd1cd55","%program_banner%":"2094","%_program_banner%":"field_642b8166eccb1","taxonomy=programs-cat":"Members"}},"id":967,"infowindow_disable":false},{"source":"post","title":"Green Community Builders at Dr. Pedro Albizu Campos High School","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/green-community-builders/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"The PACHS-GCB YouthBuild Program is a stand-alone program, since 2021, under the Emerging Program category.","address":"2739 W Division St, Chicago, IL 60622, USA","location":{"lat":"41.9027046","city":"Chicago","state":"Illinois","country":"United States","lng":"-87.6959923","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/green-community-builders/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Chicago","post_excerpt":"The PACHS-GCB YouthBuild Program is a stand-alone program, since 2021, under the Emerging Program category.","post_content":"","post_title":"Green Community Builders at Dr. Pedro Albizu Campos High School","post_link":"https://www.youthbuildillinois.org/green-community-builders/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Green Community Builders YouthBuild-Emblem\" width=\"600\" height=\"631\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/GreenCommunityBuildersYouthBuild-Emblem-600x631.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_seopress_analysis_data%":{"title":"Green Community Builders at Dr. Pedro Albizu Campos High School - IL YouthBuild","link_preview":"https://www.youthbuildillinois.org/green-community-builders/?no_admin_bar=1&preview=true","og_title":{"count":1,"values":["Green Community Builders at Dr. Pedro Albizu Campos High School"]},"og_desc":{"count":1,"values":["The PACHS-GCB YouthBuild Program is a stand-alone program, since 2021, under the Emerging Program category."]},"og_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/GreenCommunityBuildersYouthBuild-Emblem.png"]},"og_url":{"count":1,"values":["https://www.youthbuildillinois.org/green-community-builders/"],"host":"www.youthbuildillinois.org"},"og_site_name":{"count":1,"values":["IL YouthBuild"]},"tw_title":{"count":1,"values":["Green Community Builders at Dr. Pedro Albizu Campos High School"]},"tw_desc":{"count":1,"values":["The PACHS-GCB YouthBuild Program is a stand-alone program, since 2021, under the Emerging Program category."]},"tw_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/GreenCommunityBuildersYouthBuild-Emblem-1200x1261.png"]},"canonical":"https://www.youthbuildillinois.org/green-community-builders/","all_canonical":["https://www.youthbuildillinois.org/green-community-builders/"],"h1":{"nomatches":{"count":1}},"img":{"images":{"without_alt":[],"with_alt":[]}},"meta_robots":[["index, follow"]],"outbound_links":{"4":{"https://goo.gl/maps/SWAqAcpbqJ6d4JQV8":"2739 W Division Chicago, IL 60622"},"7":{"https://pachs-chicago.org/":"www.pachs-chicago.org"},"8":{"https://goo.gl/maps/LrzA84xcg1L6or7x5":"\r\n1111 South Alpine Rd., Suite 602\r\nRockford, IL 61108\r\n\r\n"},"11":{"https://www.facebook.com/IllinoisYBC/ ":""},"12":{"https://www.linkedin.com/company/illinois-youthbuild-coalition-inc.":""},"13":{"https://www.cyberoptik.net/":""}},"words_counter":515,"words_counter_unique":261},"%_edit_last%":"1","%_edit_lock%":"1685556471:1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"The PACHS-GCB YouthBuild Program is a stand-alone program, since 2021, under the Emerging Program category. The program continues to implement and solidify the PACHS-GCB YouthBuild program, to provide low-income youth a pathway to high school completion, pre-apprenticeship training that support education, occupational skills training, and employment services to at-risk-youth ages 16 to 24, while performing meaningful work and service to the community. Case management and supportive services are provided, in addition to opportunities to earn a high school diploma, occupational and life skills training as well as employment services to at-risk-youth. The program plans to serve a cohort of at least 15 stand-alone participants beginning on January 31st, 2022. The school is located in the Humboldt Park community in Chicago.\r\n","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"The Green Community Builders (GCB) is a YouthBuild Program at Dr. Pedro Albizu Campos High School. Our mission is to enhance the quality and lived experiences of program participants while creating value through community service, leadership development, as well as providing educational opportunities, and pre-apprenticeship training that may lead to family sustaining wages, and career in the construction industry and/or post-secondary pathways. Our vision is for the students to provide community service and create a legacy in the community by building low-income housing.","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<span style=\"font-weight: 400;\">Demographically, students reside in 24 different zip codes across Chicago, 91% are low-income, 68 % are Hispanic, 31% are African American, 1% are White and 50% are students in temporary living situations. We serve 59% women and 41% men within our school population.</span>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"To date, 90% of our YouthBuild participants earned their high\u00a0 school diploma, 60% completed their NCCER, OSHA10, First Aid or CPR, and\u00a0 100% completed at least 25 community service hours.","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<span style=\"font-weight: 400;\">The Green Community Builders YouthBuild Program is a pre-apprenticeship program that serves students between the ages of 16 to 24 and provides hands \u2013 on training in the construction industry. Through a holistic approach, students receive wrap-around services and earn their high school diploma through our high school. They may also earn a small stipend for participating in the program and transportation cost if needed. Our partners train the students in basic carpentry, electricity, and plumbing skills. In addition, the students obtain OSHA and NCCER certifications to be ready for entry level employment in the construction industry or further education in the construction trades.\u00a0 They also have the opportunity to earn college credit towards a degree or certificate while in high school.</span>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"We offer a primary construction career pathway with youth participant led pathways based on interest that can include Informational Technology, Hospitality, or Certified Nursing Assistant.","%_career_pathway%":"field_630d7bb19db99","%success_story%":"Robert M. is a success story.  After struggling with engagement and not finishing his high school diploma at another school, he joined Dr. Pedro Albizu Campos-Green Community YouthBuild Program to earn his high school diploma and solidify his post-secondary plans.  He is applying for colleges this week and looks forward to a career in law. He walked into the YouthBuild program with an intrinsic motivation to learn and grow. He learned to hold himself accountable and to act with integrity throughout his time in the YouthBuild program.","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul class=\"arrow-list\">\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Executive Director: Marvin Garcia</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Principal: Dr. Melissa Lewis</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Consultant on Post-Secondary Partnerships and Workforce Development: Lizzette Richardson</span></li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong> <a href=\"https://goo.gl/maps/SWAqAcpbqJ6d4JQV8\" target=\"_blank\" rel=\"noopener\">2739 W Division Chicago, IL 60622</a>\r\n\r\n<strong>Phone:</strong> <a href=\"tel:773-342-8022\">773-342-8022</a>\r\n\r\n<strong>Fax:</strong> 773-342-6609\r\n\r\n<strong>Contact Email:</strong> <a href=\"mailto:melissal@pachs-chicago.org\" target=\"_blank\" rel=\"noopener\">melissal@pachs-chicago.org</a>\r\n\r\n<strong>Website:</strong> <a href=\"https://pachs-chicago.org/\" target=\"_blank\" rel=\"noopener\">www.pachs-chicago.org</a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"6","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"green-community-builders-dr-pedro-albizu-campos-high-school","%_thumbnail_id%":"2148","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Information Technology\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Hospitality\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Certified Nursing Assistant\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Trade </span></li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%_wpgmp_location_address%":"2739 W Division St, Chicago, IL 60622, USA","%_wpgmp_location_city%":"Chicago","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"41.9027046","%_wpgmp_metabox_longitude%":"-87.6959923","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/GreenCommunityBuildersYouthBuild-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"1717","%_program_banner%":"field_642b8166eccb1","taxonomy=programs-cat":"Members"}},"id":965,"infowindow_disable":false},{"source":"post","title":"Metropolitan Family Services","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/metropolitan-family-services/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"Metro has been a pillar in the community since 1857. We are composed of several different social service components and human services entities.","address":"235 E 103rd St, Chicago, IL 60628, USA","location":{"lat":"41.7070097","city":"Chicago","state":"Illinois","country":"United States","lng":"-87.6167095","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/metropolitan-family-services/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Chicago","post_excerpt":"Metro has been a pillar in the community since 1857. We are composed of several different social service components and human services entities.","post_content":"","post_title":"Metropolitan Family Services","post_link":"https://www.youthbuildillinois.org/metropolitan-family-services/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Metro Youth Build-Emblem\" width=\"600\" height=\"644\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/MetroYouthBuild-Emblem-600x644.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_seopress_analysis_data%":{"title":"Metropolitan Family Services - IL YouthBuild","link_preview":"https://www.youthbuildillinois.org/metropolitan-family-services/?no_admin_bar=1&preview=true","og_title":{"count":1,"values":["Metropolitan Family Services"]},"og_desc":{"count":1,"values":["Metro has been a pillar in the community since 1857. We are composed of several different social service components and human services entities."]},"og_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/MetroYouthBuild-Emblem.png"]},"og_url":{"count":1,"values":["https://www.youthbuildillinois.org/metropolitan-family-services/"],"host":"www.youthbuildillinois.org"},"og_site_name":{"count":1,"values":["IL YouthBuild"]},"tw_title":{"count":1,"values":["Metropolitan Family Services"]},"tw_desc":{"count":1,"values":["Metro has been a pillar in the community since 1857. We are composed of several different social service components and human services entities."]},"tw_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/MetroYouthBuild-Emblem-1200x1287.png"]},"canonical":"https://www.youthbuildillinois.org/metropolitan-family-services/","all_canonical":["https://www.youthbuildillinois.org/metropolitan-family-services/"],"h1":{"nomatches":{"count":1}},"img":{"images":{"without_alt":[],"with_alt":[]}},"meta_robots":[["index, follow"]],"outbound_links":{"4":{"https://goo.gl/maps/EdhoGvVKSvMh8ibz7":"235 E 103rd St, Chicago, IL 60628"},"7":{"http://www.metrofamily.org":"www.metrofamily.org\u00a0"},"8":{"https://goo.gl/maps/LrzA84xcg1L6or7x5":"\r\n1111 South Alpine Rd., Suite 602\r\nRockford, IL 61108\r\n\r\n"},"11":{"https://www.facebook.com/IllinoisYBC/ ":""},"12":{"https://www.linkedin.com/company/illinois-youthbuild-coalition-inc.":""},"13":{"https://www.cyberoptik.net/":""}},"words_counter":179,"words_counter_unique":148},"%_edit_last%":"1","%_edit_lock%":"1685556471:1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"Metro has been a pillar in the community since 1857. We are composed of several different social service components and human services entities.","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"Focus on Strength\r\nAccountable\r\nMobilize for social Justice\r\nInnovative Culture\r\nLearning Organization\r\nYes Minded Approach\r\nBetter known as FAMIL","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<ul class=\"arrow-list\">\r\n \t<li>Ages 16-24 years of age</li>\r\n \t<li>Spread throughout the Chicagoland area.</li>\r\n \t<li>YouthBuild concentrates on zip codes 60617,60619,60620,60628,60636,60649, and 60827</li>\r\n</ul>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"We have had over 90% to complete the NCCER, OSHA 10, First Aid and CPR. Over 75% to attain a GED or High School Diploma.","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul class=\"arrow-list\">\r\n \t<li>Workforce</li>\r\n \t<li>Behavioral Health and Counseling</li>\r\n \t<li>Domestic Violence</li>\r\n \t<li>Housing support</li>\r\n \t<li>Education assistance</li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<ul class=\"arrow-list\">\r\n \t<li>Construction</li>\r\n \t<li>Retail</li>\r\n \t<li>Transportation</li>\r\n \t<li>WIOA</li>\r\n</ul>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"A young person who is completing our YB program is now being accepted into the electrician apprenticeship. After having challenges with math, we provided a personal tutor to assist him to pass the math portion of the test. He is a success story for as well as an inspiration to other youthbuilders.","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul class=\"arrow-list\">\r\n \t<li>Executive Director: Carrie Pullie</li>\r\n \t<li>Program Manager: Jesse Hinton</li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong> <a href=\"https://goo.gl/maps/EdhoGvVKSvMh8ibz7\" target=\"_blank\" rel=\"noopener\">235 E 103rd St, Chicago, IL 60628</a>\r\n\r\n<strong>Phone:\u00a0</strong><a href=\"tel:773-371-3611\" target=\"_blank\" rel=\"noopener\">773-371-3611\u00a0</a>\r\n\r\n<strong>Contact Email:</strong>\u00a0<a href=\"mailto:hintonj@metrofamily.org\" target=\"_blank\" rel=\"noopener\">hintonj@metrofamily.org</a>\r\n\r\n<strong>Website:\u00a0</strong><a href=\"http://www.metrofamily.org\" target=\"_blank\" rel=\"noopener\">www.metrofamily.org\u00a0</a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"5","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Retail\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Transportation\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">WIOA</span></li>\r\n \t<li>Trade</li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%_thumbnail_id%":"2150","%_wpgmp_location_address%":"235 E 103rd St, Chicago, IL 60628, USA","%_wpgmp_location_city%":"Chicago","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"41.7070097","%_wpgmp_metabox_longitude%":"-87.6167095","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/MetroYouthBuild-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"2092","%_program_banner%":"field_642b8166eccb1","taxonomy=programs-cat":"Members"}},"id":962,"infowindow_disable":false},{"source":"post","title":"Community Youth Development Institute","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/community-youth-development-institute/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"Roots of CYDI Our school community includes students from Auburn Gresham, Englewood, and surrounding Chicago communities. ","address":"7836 S Union Ave, Chicago, IL 60620, USA","location":{"lat":"41.7515907","city":"Chicago","state":"Illinois","country":"United States","lng":"-87.6418609","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/community-youth-development-institute/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Chicago","post_excerpt":"Roots of CYDI Our school community includes students from Auburn Gresham, Englewood, and surrounding Chicago communities. ","post_content":"","post_title":"Community Youth Development Institute","post_link":"https://www.youthbuildillinois.org/community-youth-development-institute/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"CYDI YouthBuild-Emblem\" width=\"600\" height=\"614\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/CYDIYouthBuild-Emblem-600x614.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_seopress_analysis_data%":{"title":"Community Youth Development Institute - IL YouthBuild","link_preview":"https://www.youthbuildillinois.org/community-youth-development-institute/?no_admin_bar=1&preview=true","og_title":{"count":1,"values":["Community Youth Development Institute"]},"og_desc":{"count":1,"values":["Roots of CYDI Our school community includes students from Auburn Gresham, Englewood, and surrounding Chicago communities."]},"og_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/CYDIYouthBuild-Emblem.png"]},"og_url":{"count":1,"values":["https://www.youthbuildillinois.org/community-youth-development-institute/"],"host":"www.youthbuildillinois.org"},"og_site_name":{"count":1,"values":["IL YouthBuild"]},"tw_title":{"count":1,"values":["Community Youth Development Institute"]},"tw_desc":{"count":1,"values":["Roots of CYDI Our school community includes students from Auburn Gresham, Englewood, and surrounding Chicago communities."]},"tw_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/CYDIYouthBuild-Emblem-1200x1227.png"]},"canonical":"https://www.youthbuildillinois.org/community-youth-development-institute/","all_canonical":["https://www.youthbuildillinois.org/community-youth-development-institute/"],"h1":{"nomatches":{"count":1}},"img":{"images":{"without_alt":[],"with_alt":[]}},"meta_robots":[["index, follow"]],"outbound_links":{"4":{"https://goo.gl/maps/Lmy7FqUM1gRxN6f2A":"7836 S. Union Ave. Chicago, IL 60620"},"6":{"http://www.cydihs.org/":"www.cydihs.org"},"7":{"https://www.facebook.com/FlyWithCYDI/":"https://www.facebook.com/FlyWithCYDI/"},"8":{"https://goo.gl/maps/LrzA84xcg1L6or7x5":"\r\n1111 South Alpine Rd., Suite 602\r\nRockford, IL 61108\r\n\r\n"},"11":{"https://www.facebook.com/IllinoisYBC/ ":""},"12":{"https://www.linkedin.com/company/illinois-youthbuild-coalition-inc.":""},"13":{"https://www.cyberoptik.net/":""}},"words_counter":1018,"words_counter_unique":491},"%_edit_last%":"1","%_edit_lock%":"1685556471:1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"Roots of CYDI Our school community includes students from Auburn Gresham, Englewood, and surrounding Chicago communities. CYDI started in 1996 due to the lack of services and the high number of out of school youth. Pastor Aaron and Mable Royster started the school as a small GED program with only 40 students in New Joy Divine Church at 76th and Halsted. The school reached the small number of youth and due to increased demand, the school began to expand. CYDI became a campus of Youth Connection Charter School in 1997 and began offering a high school diploma as a charter school. In 2002, the school relocated to the current site at 78th and Union and has grown to more than 270 students.\r\n\r\nWHAT WE DO Community Youth Development Institute (CYDI) is a community based alternative high school for youth that have not thrived in traditional settings. We are a successful alternative school because we offer a different program and different approach than schools across Chicago. We provide hands on curriculum that helps students gain marketable skills and prepare for life after high school. Our academic system provides flexibility in the ways that credit can be earned or awarded and provides students with personalized learning opportunities. These strategies include online and blended learning, dual credit and dual enrollment and, project-based and work-based learning, and credit recovery. This type of learning leads to better student engagement because the content is relevant to each student and tailored to their unique needs. It also leads to better student outcomes because the pace of learning is customized to each student. We integrate core curriculum into workbased learning opportunities throughout the program to get our students CYDI ready. They get to demonstrate mastery of job-specific skills through curriculum that is both project-based and directly connected to the competencies they are working to develop. Students working towards mastery of skills and competencies have increased ownership and motivation to complete given tasks and meet expectations. It also gives students a sense of purpose, a high level of confidence in their abilities, and ample opportunities to develop essential 21st Century skills such as critical thinking, collaboration, and communication in authentic contexts. Our system to have all of our graduates CYDI Ready has multiple pathways to graduation, makes use of integrated instructional technology, takes advantage of learning opportunities outside of school hours and walls, and help identify opportunities to target interventions to meet the specific learning needs of students.","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"Our goal at Community Youth Development Institute High School is to prepare our students to be \u201cCYDI Ready,\u201d which we use as a flexible concept that encompasses both college- and career-readiness. In many cases, students will work towards both at once- many of our students graduate high school with not only their diploma in hand, but also some college credit, work experience and/or a specific industry certification.","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"The CYDI student body consists of students ranging in age from 16-20 with the majority of our students residing in the Auburn Gresham, Englewood, and surrounding communities.","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"The school has graduated more than 1200 students with many of those students going on to attended community colleges, local colleges, HBCU\u2019s military and other vocational opportunities Level 1 School- CPS SQRP","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul class=\"arrow-list\">\r\n \t<li>Hands-on Learning Labs \u2013 Construction, 3-D Printing, Fashion Design, Music Production and Recording, Personal Care, Urban Agriculture, Graphic Design</li>\r\n \t<li>Virtual Reality and Gaming Construction Pre-Apprenticeship program</li>\r\n \t<li>Job Training Certifications Comprehensive Support Services Work Base Experience Dual Enrollment</li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<ul class=\"arrow-list\">\r\n \t<li>Construction</li>\r\n \t<li>Construction Pre-Apprenticeship</li>\r\n \t<li>Digital Graphic Design</li>\r\n \t<li>Fashion Design</li>\r\n \t<li>Urban Agriculture</li>\r\n \t<li>Entrepreneurship</li>\r\n \t<li>3-D Industrial Design</li>\r\n \t<li>Digital Multimedia</li>\r\n \t<li>Information Technology</li>\r\n</ul>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"It is an understatement to say that his life has been challenging. Michael* has dealt with addiction, poor attendance and grades, and involvement in the justice system. Attempts were made by the YB staff to deal with his drug use and improve his performance at school. The final blow was when his family evicted him from his home and charged him with domestic battery. While providing counseling and support throughout his difficulties, the YB team believed this was a turning point for Michael*. Previous employment efforts were not successful due to his lack of commitment in maintaining regular attendance and tardiness. The team stepped in, found him housing and provided transportation and support with his various court appearances. Michael* began to realize that the change had to come from him. He then began to realize and appreciate the support he had from the YB team and vowed to do better.\r\n\r\nAfter a series of unsuccessful attempts at finding employment Michael* began to show signs of wanting more for himself. We believe another turning point was when he was slated for hire by one of the YB employment partners but was turned down due to his open domestic battery case. At this point Michael* became serious about changing his circumstances. The team recognized the changes in his behavior and assured him that he had our support. He was introduced to the Strong Futures program housed at St. Sabina Church. This program helps young males involved in the justice system and provides a comprehensive mentoring, substance abuse and job placement program. The Job Developer assisted him providing all the necessary paperwork and served as a character reference. She also served as the liaison for the school and YB program. We are happy to report that Michael* successfully completed their training program and started a position at a local area restaurant. While there he learned the importance of time management, workplace decorum and managing peer and manager relationships. He began to have regular attendance at school, completed his coursework and graduated in June 2021 with his high school diploma. Michael* now has his own apartment and began working at a big box retailer in September. As of January, he is still employed making $19 an hour. While the pandemic has upended the lives of many people, Michael is an example of how you can succeed despite the odds.\r\n\r\n*name changed to protect student\u2019s privacy.","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul class=\"arrow-list\">\r\n \t<li>Executive Director: Aaron Royster</li>\r\n \t<li>Program Director: Tamiko Winn</li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong>\u00a0<a href=\"https://goo.gl/maps/Lmy7FqUM1gRxN6f2A\" target=\"_blank\" rel=\"noopener\">7836 S. Union Ave. Chicago, IL 60620</a>\r\n\r\n<strong>Phone:\u00a0</strong><a href=\"tel:773-224-2273\" target=\"_blank\" rel=\"noopener\">773-224-2273\u00a0</a>\r\n\r\n<strong>Website:\u00a0</strong><a href=\"http://www.cydihs.org/\" target=\"_blank\" rel=\"noopener\">www.cydihs.org</a>\r\n<h4><strong>Social Media:</strong></h4>\r\n<strong>Facebook</strong>:\u00a0<a href=\"https://www.facebook.com/FlyWithCYDI/\" target=\"_blank\" rel=\"noopener\">https://www.facebook.com/FlyWithCYDI/</a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"4","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"chicago","%_thumbnail_id%":"2147","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Construction Pre-Apprenticeship\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Digital Graphic Design\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Fashion Design\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Urban Agriculture\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Entrepreneurship\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">3-D Industrial Design\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Digital Multimedia\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Information Technology\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Trade\u00a0</span></li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%_wpgmp_location_address%":"7836 S Union Ave, Chicago, IL 60620, USA","%_wpgmp_location_city%":"Chicago","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"41.7515907","%_wpgmp_metabox_longitude%":"-87.6418609","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/CYDIYouthBuild-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"1720","%_program_banner%":"field_642b8166eccb1","taxonomy=programs-cat":"Members"}},"id":960,"infowindow_disable":false},{"source":"post","title":"Housing Authority of Champaign County","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/housing-authority-of-champaign-county-youthbuild/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"Since 2020, the Housing Authority of Champaign County (HACC) has delivered the YouthBuild program for 84 youth ages 16-24 who have dropped out of high school and who are interested in pursuing careers in the trades. ","address":"S Market St, Champaign, IL 61820, USA","location":{"lat":"40.1144477","city":"Champaign City Township","state":"Illinois","country":"United States","lng":"-88.24265559999999","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/housing-authority-of-champaign-county-youthbuild/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Champaign","post_excerpt":"Since 2020, the Housing Authority of Champaign County (HACC) has delivered the YouthBuild program for 84 youth ages 16-24 who have dropped out of high school and who are interested in pursuing careers in the trades. ","post_content":"","post_title":"Housing Authority of Champaign County","post_link":"https://www.youthbuildillinois.org/housing-authority-of-champaign-county-youthbuild/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Illinois Youth Build Coalition-Emblem\" width=\"600\" height=\"631\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/IllinoisYouthBuildCoalition-Emblem-600x631.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"1","%_edit_lock%":"1685556472:1","%_seopress_analysis_data%":{"title":"Housing Authority of Champaign County - IL YouthBuild","link_preview":"https://www.youthbuildillinois.org/housing-authority-of-champaign-county-youthbuild/?no_admin_bar=1&preview=true","og_title":{"count":1,"values":["Housing Authority of Champaign County"]},"og_desc":{"count":1,"values":["Since 2020, the Housing Authority of Champaign County (HACC) has delivered the YouthBuild program for 84 youth ages 16-24 who have dropped out of high school and who are interested in pursuing careers in the trades."]},"og_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/IllinoisYouthBuildCoalition-Emblem.png"]},"og_url":{"count":1,"values":["https://www.youthbuildillinois.org/housing-authority-of-champaign-county-youthbuild/"],"host":"www.youthbuildillinois.org"},"og_site_name":{"count":1,"values":["IL YouthBuild"]},"tw_title":{"count":1,"values":["Housing Authority of Champaign County"]},"tw_desc":{"count":1,"values":["Since 2020, the Housing Authority of Champaign County (HACC) has delivered the YouthBuild program for 84 youth ages 16-24 who have dropped out of high school and who are interested in pursuing careers in the trades."]},"tw_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/IllinoisYouthBuildCoalition-Emblem-1200x1261.png"]},"canonical":"https://www.youthbuildillinois.org/housing-authority-of-champaign-county-youthbuild/","all_canonical":["https://www.youthbuildillinois.org/housing-authority-of-champaign-county-youthbuild/"],"h1":{"nomatches":{"count":1}},"img":{"images":{"without_alt":[],"with_alt":[]}},"meta_robots":[["index, follow"]],"outbound_links":{"4":{"https://goo.gl/maps/Rq8dtBscKQj7GTWn6":"2008 N. Market St., Champaign, IL, 61820"},"7":{"https://hacc.net/hacc-youthbuild":"https://hacc.net/hacc-youthbuild"},"8":{"https://www.facebook.com/HACCYouthBuild":"https://www.facebook.com/HACCYouthBuild"},"9":{"https://goo.gl/maps/LrzA84xcg1L6or7x5":"\r\n1111 South Alpine Rd., Suite 602\r\nRockford, IL 61108\r\n\r\n"},"12":{"https://www.facebook.com/IllinoisYBC/ ":""},"13":{"https://www.linkedin.com/company/illinois-youthbuild-coalition-inc.":""},"14":{"https://www.cyberoptik.net/":""}},"words_counter":572,"words_counter_unique":334},"%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"Since 2020, the Housing Authority of Champaign County (HACC) has delivered the YouthBuild program for 84 youth ages 16-24 who have dropped out of high school and who are interested in pursuing careers in the trades. Participants of our YouthBuild program include those who have been incarcerated, who have a disability, who are migrants, who are in the foster system, who experience homelessness, and who are food insecure. These students are afforded an opportunity to receive a high-school diploma and certification in their trade of choice. Youth undertake a rigorous curriculum centered around the three pillars of construction, education, and leadership training. The program provides six months of classroom instruction, followed by a 12-month follow-up period where supportive services are provided to prepare them for further education or employment. While there are many YouthBuild programs throughout the United States and beyond, ours is one of the few that is managed by a Public Housing Authority. By offering this program through HACC, we have ready access to eligible young people and are able to address participants\u2019 housing needs by offering them housing vouchers. In addition, program participants gain hands-on training by assisting with repairs and enhancements to our affordable housing stock. The YouthBuild program supports our mission to create and maintain quality affordable living environments and to help individuals achieve their fullest potential.","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"#building brighter futures","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<ul class=\"arrow-list\">\r\n \t<li><strong>Male</strong>: 32</li>\r\n \t<li><strong>Female</strong>:36</li>\r\n \t<li><strong>Low Income</strong>: 68</li>\r\n \t<li><strong>HS Dropout</strong>: 65</li>\r\n \t<li><strong>Youth Offender</strong>: 5</li>\r\n \t<li><strong>Basic Skills Deficient</strong>: 58</li>\r\n \t<li><strong>Not Employed at Program Enrollment</strong>: 68</li>\r\n \t<li><strong>Job placements following program completion</strong>: 21</li>\r\n</ul>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"44 high school diploma graduates\r\n946 total earned credits \r\n3.2 cumulative program grade point average\r\n68/84 students serviced through the YouthBuild grant \r\n4/4 Transition to Independence Program housing placements\r\n1/1 Family Support Program housing placements\r\n4/5 YouthBuild housing voucher placements \r\n5/5 Bright Futures Internship Program placements\r\n3 YouthBuild alumni employment placements within HACC","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul class=\"arrow-list\">\r\n \t<li>Transition to Independence Program</li>\r\n \t<li>Family Support Program</li>\r\n \t<li>YouthBuild Housing Choice Voucher Program</li>\r\n \t<li>Bright Futures Internship Program</li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<ul class=\"arrow-list\">\r\n \t<li>Construction</li>\r\n \t<li>IT</li>\r\n \t<li>HealthCare</li>\r\n \t<li>Home Health Aide</li>\r\n \t<li>Hotel &amp; Restaurant Management</li>\r\n</ul>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"\u201cI have had the unique experience of being a part of the Housing Authority of Champaign County\u2019s YouthBuild program, and the cool standing of originating from our program\u2019s very first cohort that started on June 1st, 2020. Despite\r\nbeing a recent high school graduate, I experienced a lot of difficulty finding stable and sustainable employment so that I could provide for my children. I have also faced legal troubles in my past which also prevented me from employment and education opportunities. Through YouthBuild I was able to gain career certifications, mentorship, and life experiences which have expanded opportunities for me both personally and professionally. Through the YouthBuild program I have received the following credentials: OSHA 10, Flaggers, NCCER, and Nail Tech Certification. I was also hired to participate in the Housing Authority\u2019s bright futures internship program which offers young people like myself entry level career opportunities in the housing industry. Today, I am proud to report that I will celebrate my 1-year anniversary as a full-time employee of the Housing Authority on April 5th, 2022. In addition to that I am also in college working on completing a bachelor\u2019s degree in business administration. None of this would be possible without the support and guidance I have received from the YouthBuild program.\u201c\r\n\r\n\u2013 Tashanee Turner, Alumni student and HACC Receptionist","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul class=\"arrow-list\">\r\n \t<li><strong>Executive Director:</strong> Lily Walton</li>\r\n \t<li><strong>Program Director:</strong> Shevone Myrick</li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong>\u00a0<a href=\"https://goo.gl/maps/Rq8dtBscKQj7GTWn6\" target=\"_blank\" rel=\"noopener\">2008 N. Market St., Champaign, IL, 61820</a>\r\n\r\n<strong>Phone:\u00a0</strong><a href=\"tel:217-372-5590\" target=\"_blank\" rel=\"noopener\">217-372-5590</a>\r\n\r\n<strong>Contact Email:</strong>\u00a0<a href=\"mailto:shevonem@hacc.net\" target=\"_blank\" rel=\"noopener\">shevonem@hacc.net</a>\r\n\r\n<strong>Website:\u00a0</strong><a href=\"https://hacc.net/hacc-youthbuild\" target=\"_blank\" rel=\"noopener\">https://hacc.net/hacc-youthbuild</a>\r\n<h4><strong>Social Media</strong></h4>\r\n<strong>Facebook</strong>:\u00a0<a href=\"https://www.facebook.com/HACCYouthBuild\" target=\"_blank\" rel=\"noopener\">https://www.facebook.com/HACCYouthBuild</a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"3","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"champaign","%_thumbnail_id%":"2149","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Information Technology\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Healthcare\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Home Health Aide\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Hotel &amp; Restaurant Management\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Trade\u00a0</span></li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%_wpgmp_location_address%":"S Market St, Champaign, IL 61820, USA","%_wpgmp_location_city%":"Champaign City Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"40.1144477","%_wpgmp_metabox_longitude%":"-88.24265559999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YBMonogram-OrangeBlue.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"1721","%_program_banner%":"field_642b8166eccb1","taxonomy=programs-cat":"Members"}},"id":958,"infowindow_disable":false},{"source":"post","title":"YouthBuild McLean County, Inc.","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/youthbuild-mclean-county-inc/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"YouthBuild McLean County has served the youth of McLean County since 1994. ","address":"360 Wylie Dr suite 305, Normal, IL 61761, USA","location":{"lat":"40.4963997","city":"Normal Township","state":"Illinois","country":"United States","lng":"-89.03394580000001","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/youthbuild-mclean-county-inc/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Bloomington-Normal","post_excerpt":"YouthBuild McLean County has served the youth of McLean County since 1994. ","post_content":"","post_title":"YouthBuild McLean County, Inc.","post_link":"https://www.youthbuildillinois.org/youthbuild-mclean-county-inc/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"YouthBuild McLean County-Emblem\" width=\"600\" height=\"644\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildMcLeanCounty-Emblem-600x644.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_seopress_analysis_data%":{"title":"YouthBuild McLean County, Inc. - IL YouthBuild","link_preview":"https://www.youthbuildillinois.org/youthbuild-mclean-county-inc/?no_admin_bar=1&preview=true","og_title":{"count":1,"values":["YouthBuild McLean County, Inc."]},"og_desc":{"count":1,"values":["YouthBuild McLean County has served the youth of McLean County since 1994."]},"og_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildMcLeanCounty-Emblem.png"]},"og_url":{"count":1,"values":["https://www.youthbuildillinois.org/youthbuild-mclean-county-inc/"],"host":"www.youthbuildillinois.org"},"og_site_name":{"count":1,"values":["IL YouthBuild"]},"tw_title":{"count":1,"values":["YouthBuild McLean County, Inc."]},"tw_desc":{"count":1,"values":["YouthBuild McLean County has served the youth of McLean County since 1994."]},"tw_img":{"count":1,"values":["https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildMcLeanCounty-Emblem-1200x1287.png"]},"canonical":"https://www.youthbuildillinois.org/youthbuild-mclean-county-inc/","all_canonical":["https://www.youthbuildillinois.org/youthbuild-mclean-county-inc/"],"h1":{"nomatches":{"count":1}},"img":{"images":{"without_alt":[],"with_alt":[]}},"meta_robots":[["index, follow"]],"outbound_links":{"4":{"https://goo.gl/maps/3pDjK5kHyNoFzxHB8":"360 Wylie Drive, Suite 305, Normal, IL 61761"},"7":{"https://www.youthbuildmcleancounty.org/":"https://www.youthbuildmcleancounty.org/\u00a0"},"8":{"https://goo.gl/maps/LrzA84xcg1L6or7x5":"\r\n1111 South Alpine Rd., Suite 602\r\nRockford, IL 61108\r\n\r\n"},"11":{"https://www.facebook.com/IllinoisYBC/ ":""},"12":{"https://www.linkedin.com/company/illinois-youthbuild-coalition-inc.":""},"13":{"https://www.cyberoptik.net/":""}},"words_counter":736,"words_counter_unique":387},"%_edit_last%":"1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"YouthBuild McLean County has served the youth of McLean County since 1994. We have partnered with young people who have struggled in traditional education systems complete their high school education, gain career skills in demand occupations, helped develop leadership skills, provided mentors and comprehensive supportive case management services, and conducted community service to improve the lives of our students, their families and their fellow community members. We have constructed or remodeled over 200 residential properties providing opportunities for access to affordable, quality housing.","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"It is YouthBuild McLean County\u2019s mission to build, develop, inspire, and challenge educationally and economically disadvantaged students to make the difference!","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"We serve youth with the following demographics\r\n<ul class=\"arrow-list\">\r\n \t<li>50% Caucasian</li>\r\n \t<li>40% African American</li>\r\n \t<li>7% Hispanic</li>\r\n \t<li>3% Other races or chose not to identify</li>\r\n \t<li>25% of student population identifies as female</li>\r\n \t<li>35% are young parents</li>\r\n \t<li>75% are associated with the justice system.</li>\r\n</ul>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"We have assisted over 2000 youth in completing educational and vocational goals. We have constructed or reconstructed over 200 units of housing in McLean County. We have completed over 1,000,000 hours of service to the community.","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul class=\"arrow-list\">\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Accredited Public Charter High School with McLean County Unit 5 school district\u00a0</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Accredited Private High School YouthBuild Academy\u00a0</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">National Certification in Vocational Programs: NCCER Carpentry, CNA, and COMP TIA.</span></li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"<ul class=\"arrow-list\">\r\n \t<li>Healthcare</li>\r\n \t<li>Residential Construction</li>\r\n \t<li>Information Technology</li>\r\n</ul>","%_career_pathway%":"field_630d7bb19db99","%success_story%":"AA struggled in traditional school. Although her academic skills were very high, she experienced long periods of absenteeism and high anxiety because her father was deported to Mexico in 2019. In an effort to stay connected, and despite the cost and time, the family would travel to Mexico regularly. Finding herself deficient in many credits to achieve graduation on time, AA determined she would look for alternative education pathways. She was particularly interested in the vocational training offered at YouthBuild McLean County while she was working on completing her high school education. AA's career goal was to learn construction and how to manage construction projects with her ultimate goal being to own her own construction company. AA enrolled in YouthBuild in Fall of 2020. She also applied and was accepted into the Construction Vocational Training program. Working with YouthBuild Construction staff, AA learned the tasks involved in a comprehensive home remodel. She assisted in demolition and deconstruction, framing, installing windows and doors, hanging sheetrock, landscaping, painting, installing cabinets and fixtures, construction safety and tool recognition and many other skills. While working on the construction site project house, AA also continued work on her high school diploma course work and completed the National Center for Construction Education and Research (NCCER) Core Carpentry Certification, a nationally recognized industry credential. She also earned her first aid and CPR certification and OSHA 10 certification. AA received mentoring services, mental health services, career readiness services and other supportive services to help her stay on track and achieve her education and career goals while in YouthBuild. AA completed two college courses through YouthBuild\u2019s dual credit program with Heartland Community College. AA thrived with the competency-based learning model at YouthBuild and was able to make up lost credits quickly and proficiently. AA\u2019s attendance was excellent and while in YouthBuild, she enrolled in AmeriCorps and completed 450 hours of service in addition to her course work. She helped build raised garden beds for the Sunnyside Community Garden, build animal habitats for the Miller Park Zoo and constructed food boxes for families in need at the Midwest Food Bank amongst other projects. In April 2021, AA was awarded a $12,000 scholarship to Heartland Community College to pursue an associate\u2019s in applied science degree in Construction Project Management. She will also earn an AmeriCorps education award for her work in community service. In August 2021, AA was a member of the graduating class at YouthBuild. She was also awarded the Suzanne Fitzgerald Leadership Award, the highest award at YouthBuild, \u201cfor demonstrating leadership excellence and inspiring others to perform at their best\u201d. She is enrolled as a fulltime student at Heartland Community College and will being classes in August 2021. AA will also be coming back to YouthBuild in September 2021 as a work-study student through Heartland to assist the Construction Vocational Instructor train new YouthBuild students.","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul class=\"arrow-list\">\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Executive Director: Tracey Polson</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Chief Finance Officer: Michelle Klatt</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Education Director: Kevin Bradley</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Lead Case Manager: Bertram Givan (YouthBuild Graduate)</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Register/Data Manager: Stacy Van</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Facilities Maintenance Director: Ryan Dowell (YouthBuild Graduate)</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Supportive Services Director: Robin King</span></li>\r\n \t<li style=\"font-weight: 400;\" aria-level=\"3\"><span style=\"font-weight: 400;\">Development Specialist: Kersten Wilson</span></li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong>\u00a0<a href=\"https://goo.gl/maps/3pDjK5kHyNoFzxHB8\" target=\"_blank\" rel=\"noopener\">360 Wylie Drive, Suite 305, Normal, IL 61761</a>\r\n\r\n<strong>Phone:</strong>\u00a0<a href=\"tel:309-454-3898\" target=\"_blank\" rel=\"noopener\">309-454-3898</a>\r\n\r\n<strong>Contact Email:</strong>\u00a0<a href=\"mailto:tpolson@ybmc.org\" target=\"_blank\" rel=\"noopener\">tpolson@ybmc.org</a>\r\n\r\n<strong>Website:\u00a0</strong><a href=\"https://www.youthbuildmcleancounty.org/\" target=\"_blank\" rel=\"noopener\">https://www.youthbuildmcleancounty.org/\u00a0</a>","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"2","%_edit_lock%":"1685556472:1","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_thumbnail_id%":"2153","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Healthcare\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Residential Construction\u00a0\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Information Technology </span></li>\r\n \t<li>Trade</li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%_wpgmp_location_address%":"360 Wylie Dr suite 305, Normal, IL 61761, USA","%_wpgmp_location_city%":"Normal Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"40.4963997","%_wpgmp_metabox_longitude%":"-89.03394580000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"a:1:{i:0;s:1:\"9\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2023/02/YouthBuildMcLeanCounty-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"1706","%_program_banner%":"field_642b8166eccb1","taxonomy=programs-cat":"Members"},"icon":"https://www.youthbuildillinois.org/wp-content/plugins/wp-google-map-gold/assets/images//default_marker.png"},"id":956,"infowindow_disable":false},{"source":"post","title":"Quad County Urban League","infowindow_content":"<div class=\"fc-item-box fc-itemcontent-padding \">\r\n<h4>{marker_title}</h4>\r\n<p>{marker_address}</p>\r\n<p class=\" program-more\"><a href=\"https://www.youthbuildillinois.org/program/quad-county-urban-league/\" class=\"button program-button\" style=\"font-family: var(--font-1) !important;\">Learn More</a></p>\r\n\r\n</div>","content":"The accomplishments achieved during its 46-year history effecting positive changes in the Quad County service area are testaments to the QCUL\u2019s ability to manage programs and successfully meet expected outcomes.","address":"Aurora, IL, USA","location":{"lat":"41.7605849","city":"Aurora Township","state":"Illinois","country":"United States","lng":"-88.32007150000001","onclick_action":"marker","redirect_permalink":"https://www.youthbuildillinois.org/program/quad-county-urban-league/","zoom":1,"extra_fields":{"%youthbuild_member_sites%":"Aurora","post_excerpt":"The accomplishments achieved during its 46-year history effecting positive changes in the Quad County service area are testaments to the QCUL\u2019s ability to manage programs and successfully meet expected outcomes.","post_content":"","post_title":"Quad County Urban League","post_link":"https://www.youthbuildillinois.org/program/quad-county-urban-league/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Aurora YouthBuild-Emblem\" width=\"600\" height=\"631\" src=\"https://www.youthbuildillinois.org/wp-content/uploads/2022/09/AuroraYouthBuild-Emblem-600x631.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_last%":"6","%_edit_lock%":"1710464596:1","%_wp_page_template%":"default","%_seopress_redirections_type%":"301","%_seopress_redirections_logged_status%":"both","%title_location%":"default","%intro_text%":"","%banner%":"default","%banner_color%":"","%banner_opacity%":"default","%breadcrumbs%":"default","%slider%":"","%_youthbuild_member_sites%":"field_630d7c683981a","%brief_history%":"The accomplishments achieved during its 46-year history effecting positive changes in the Quad County service area are testaments to the QCUL\u2019s ability to manage programs and successfully meet expected outcomes. QCUL is currently a YBUSA affiliate and has effectively managed two IYC YouthBuild grant awards in 2020 and 2021. The organization was also a recipient of the 2009 YouthBuild grant, and other grants awarded by public and private institutions to serve out-of-school and at-risk populations as described in this section below. Experience gained while managing the prior YouthBuild programs, other DOL Workforce Investment Opportunity Act (WIOA) programs, ComEd\u2019s CONSTRUCT Program, Nicor Gas\u2019 Career Academy (NGCA), UPS\u2019 Plant Engineer Mechanic Training and Solar Jobs training have uniquely positioned QCUL to successfully lead the 2022 Aurora YouthBuild Program\r\n","%_brief_history%":"field_630d7168c1ab8","%mission_statement_and_or_core_values%":"The mission of the training is to offer a career path that builds skills, knowledge, and networks that promote career advancement for lowincome and underserved youth, which will help them develop construction and carpentry skills that prepare them to enroll in registered apprenticeship programs in the construction trades.","%_mission_statement_and_or_core_values%":"field_630d7347391eb","%student_demographics%":"<span style=\"font-weight: 400;\">YouthBuild Program in Aurora, Illinois, will serve 20 youth ages 16-24 in zip codes 60505, 60506, and 60538.</span><b>\u00a0</b>","%_student_demographics%":"field_630d7b129db96","%accomplishments%":"QCUL has maintained its ongoing partnership with the Aurora Housing Authority (AHA). Due to Covid in FY21, QCUL needed more outside projects. To ensure that the participants gained construction skills, QCUL partnered with Rebuilding Together Aurora on several community projects during FY21. The projects included building an ADA ramp for a disabled senior and rehabilitation/ repairs to the interior of a community resident\u2019s home.","%_accomplishments%":"field_630d7b539db97","%programs_offered%":"<ul>\r\n \t<li>DOL Workforce Investment Opportunity Act (WIOA) programs</li>\r\n \t<li>ComEd\u2019s CONSTRUCT Program</li>\r\n \t<li>Nicor Gas\u2019 Career Academy (NGCA)</li>\r\n \t<li>UPS\u2019 Plant Engineer Mechanic Training and Solar Jobs training are offered at The Quad County Urban League</li>\r\n</ul>","%_programs_offered%":"field_630d7b7a9db98","%career_pathway%":"The Fox Valley Building and Construction Trades Council and the Painters District Council #30 Joint Apprenticeship &amp; Training Fund will serve as registered apprenticeship partners for the 2022 program. Partners are committed to ongoing relationships for apprenticeships and job placement opportunities for the YouthBuild program participants. These companies selected for placement of participants have union employees. These trade unions have apprenticeship programs where QCUL participants have transitioned into job opportunities where applicants move through the construction industry programs. QCUL participants have been hired as laborers, electrical workers, and plumbers which allows them to transition into apprenticeship programs with QCUL\u2019s corporate partners. Given the success of these other workforce development initiatives, QCUL will leverage its established processes and tools to engage employers for continued participation.","%_career_pathway%":"field_630d7bb19db99","%success_story%":"Manuel Dominguez entered YouthBuild through our high school credit recovery program. After successfully completing high school, he is currently enrolled with our ComEd Construct Program and is entering a Welding program in August 2022 through Waubonsee Community College.","%_success_story%":"field_630d7bd89db9a","%leadership%":"<ul>\r\n \t<li>President &amp; CEO: Theodia Gillespie</li>\r\n \t<li>Program Director: Katrina Henderson</li>\r\n</ul>","%_leadership%":"field_630d7bf99db9b","%contact_info%":"<strong>Address:</strong> <a href=\"https://goo.gl/maps/eiw7mCxbyTKKjcQD6\" target=\"_blank\" rel=\"noopener\">1685 N. Farnsworth Ave, Aurora IL 60506</a>\r\n\r\nPhone: <a href=\"tel:630-851-2203\">630-851-2203</a>\r\n\r\nContact Email: <a href=\"mailto:KatrinaHenderson@qcul.org\">KatrinaHenderson@qcul.org</a>\r\n\r\nWebsite: <a href=\"https://www.qcul.org\">https://www.qcul.org</a>\r\n\r\nSocial Media: @quadcountyurbanleague","%_contact_info%":"field_630d7c199db9c","%_reorder_term_programs-cat_members%":"1","%programs_thumb%":"","%_programs_thumb%":"field_633bbb79132c0","%_wp_old_slug%":"aurora","%program_thumb%":"","%_program_thumb%":"field_6371f6e9cd507","%career_pathways%":"<ul>\r\n \t<li><span style=\"font-weight: 400;\">Construction\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Trade\u00a0</span></li>\r\n \t<li><span style=\"font-weight: 400;\">Apprenticeship </span></li>\r\n</ul>","%_career_pathways%":"field_630d7bb19db99","%_thumbnail_id%":"2143","%_wpgmp_location_address%":"Aurora, IL, USA","%_wpgmp_location_city%":"Aurora Township","%_wpgmp_location_state%":"Illinois","%_wpgmp_location_country%":"United States","%_wpgmp_metabox_latitude%":"41.7605849","%_wpgmp_metabox_longitude%":"-88.32007150000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"5\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%map_program_thumbnail%":"https://www.youthbuildillinois.org/wp-content/uploads/2022/09/AuroraYouthBuild-Emblem.png","%_map_program_thumbnail%":"field_6423ea70ca121","%program_banner%":"2095","%_program_banner%":"field_642b8166eccb1","%_elementor_edit_mode%":"builder","%_elementor_template_type%":"wp-post","%_elementor_version%":"3.20.1","%_elementor_pro_version%":"3.20.0","%_elementor_css%":{"time":1712158450,"fonts":[],"icons":[],"dynamic_elements_ids":[],"status":"empty","0":"","css":""},"taxonomy=programs-cat":"Members"}},"id":927,"infowindow_disable":false}],"listing":{"listing_header":"Locations Listing","display_search_form":true,"search_field_autosuggest":false,"display_category_filter":false,"display_sorting_filter":false,"display_radius_filter":false,"radius_dimension":"miles","radius_options":"10,25,50,100,200","apply_default_radius":false,"default_radius":"25","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_listing5","tabs_container":".location_listing5","hide_locations":false,"filters_position":"default","hide_map":false,"pagination":{"listing_per_page":"100"},"list_grid":"wpgmp_listing_list","listing_placeholder":"<section class=\"section program\">\r\n<a class=\"program-link\" href=\"{post_link}\">\r\n<div class=\"grid grid-spaced-lg\">\r\n<div class=\"col-third program-thumb-wrap\">\r\n{marker_image}\r\n</div>\r\n<div class=\"col-two-thirds program-text-wrap\">\r\n<h3 class=\"program-title\">{marker_title}</h3>\r\n<h5 class=\"program-town\">{%youthbuild_member_sites%}</h5>\r\n<p class=\"program-excerpt\">{marker_message}\r\n</p><p class=\"program-more\"><span class=\"button program-button\">Learn More</span></p>\r\n</div>\r\n</div>\r\n</a>\r\n</section>","list_item_skin":{"name":"fano","type":"item","sourcecode":"<section class=\"section program\">\r\n<a class=\"program-link\" href=\"{post_link}\">\r\n<div class=\"grid grid-spaced-lg\">\r\n<div class=\"col-third program-thumb-wrap\">\r\n{marker_image}\r\n</div>\r\n<div class=\"col-two-thirds program-text-wrap\">\r\n<h3 class=\"program-title\">{marker_title}</h3>\r\n<h5 class=\"program-town\">{%youthbuild_member_sites%}</h5>\r\n<p class=\"program-excerpt\">{marker_message}\r\n</p><p class=\"program-more\"><span class=\"button program-button\">Learn More</span></p>\r\n</div>\r\n</div>\r\n</a>\r\n</section>"}},"map_property":{"map_id":"5","debug_mode":false},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"filters_container":"[data-container=\"wpgmp-filters-container\"]"}}

DONATE

The Illinois YouthBuild Coalition relies on donations to carry out our mission to expand employment and career opportunities for opportunity youth. Your gift enables IYC to support a YouthBuild Program near you. Because of you, more low-income, minority youth can receive the education, training, and resources they need.