{"status":"success","username":"labellecorp","page_id":70349,"firstname":"LBC Entertainment Podcast with Vivy K","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"text\",\"header\":\"LaBelle Corp - The LaBelle Businesses\",\"data\":[{\"localHTML\":\"<p>With LaBelle Consult's excellent delivery in making an impact by managing sustainability and effecting the impossible, making life a lot easier for individuals and organizations, we have obtained a competitive edge in the consulting and business industries.<\/p><p>We are a consulting company that connects clients with properly trained, accountable, and qualified skilled workers, artisans, and professionals. We are slowly paving the way in the HR and business industries. Our goal is to impact lives and, in line with the SDGs, eradicate poverty by promoting good and decent work.<\/p>\"}]}","{\"type\":\"card\",\"header\":\"Our Services \",\"subheader\":\"We deliver a wide range of services, mainly in -  Hiring, Training, Consulting & Capacity Development. While our major focus is HR Services\/Consulting\u2014hiring and training; we also run procurement projects on the supply of interiors like furniture and household electronics with branded manufacturers in Turkey and Nigeria as a form of regulating the supply services our artisans may be requested to render to our customers. So we establish partnerships with wholesale manufacturing companies to offer other business services and procurement. As a company that represents the UN SDGs 1, 5, 8, and 10, we love to give back to society, and to that effect, we founded a support initiative called the Wompreneur Network Initiative that empowers indigenous women, especially widows, oppressed women, and single mothers, around Africa through our free entrepreneurial, skill development training and empowerment programs.\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/ea9f8eab-7fd9-48d9-bc71-15369f1e0849\/UuueZJvKtWVDQFKz9vAo2RlmaeYl3FHgR9h6m2A2.jpg\",\"title\":\"Training and Capacity Development Programs \",\"altText\":\"\",\"url\":\"https:\/\/forms.gle\/mgY4GCALFndqNXnU7\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/80401119-5b8f-4fbb-9b9a-b2f20aded797\/b0fhkEFeaOZVmodE990Hs7e1vTQTm9ZB8JjVnOvG.jpg\",\"title\":\"Our Hiring Services\",\"altText\":\"Hiring a good employees whether corporate, domestic, freelance, or maintenance can be tasking. We serve individuals, expatriates, offices and especially fast-paced businesses like hotels, apartments and lounges, NGOs, Oil & Gas etc where the value for quality is on high demand. LaBelle Consult Ltd exists for tough moments like this. We have the best engineers, corporate staffs, technicians, domestic and maintenance team for your business sustainability.  Contact us to make a hire now.\",\"url\":\"https:\/\/forms.gle\/QqXqaLvUBUW9QWn99\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/c78f0ed6-4ef1-4d86-afd1-cf273657aaec\/N2WshftuuKP7tlWmaT6eOutyyyVpdSIRkJRtiW0h.jpg\",\"title\":\"Our Online Courses \",\"altText\":\"Gain National and International Certificates in collaboration with our partner institutions across Europe, Nigeria and USA on completion of any of our courses. \",\"url\":\"https:\/\/bit.ly\/lbctrainingform\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/f072c0ec-10a6-4815-8892-931c0c72d22c\/P6YxoQUbGkT6eMUT1rFGZutCw0I5ajmf0JNwqdVr.jpg\",\"title\":\"Green Skills Training \",\"altText\":\"Courses on Green skills \",\"url\":\"https:\/\/bit.ly\/lbctrainingform\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/8c87f06a-f46c-44ee-af8c-e20d951be095\/79Y2U8louYtCD5Zyp0k0V2BvRKdnM7HL7AXmdBuJ.png\",\"title\":\"Procurement and Business Services \",\"altText\":\"For your home, hotel or office furnishing purchase branded electronics and home appliances from the manufacturers through us at the best prices. We are the No. 1 suppliers of Panasonic, LG, Samsung, Hisence, Midea, Daikin, Skyrun and other top brands of electronics in Nigeria. \",\"url\":\"https:\/\/www.canva.com\/design\/DAFicdanlTs\/F3hvvg7lpsTCYyk9Pe49Tw\/view?utm_content=DAFicdanlTs&utm_campaign=designshare&utm_medium=link&utm_source=publishsharelink\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/c52f8c02-caa8-4f00-a63e-14bda5aead69\/7dRMa8JPLm38tIZ3dcX9GBcs6EfHAPE21632v4Fc.jpg\",\"title\":\"Partnerships and Collaborations \",\"altText\":\"For us, building the right partnerships and collaborations is the key to the success of any business. We are calling on individuals, organizations  and businesses from any industry, all around the world; let us explore the HR and business industries together. Send us an email and let\u2019s explore various options in hiring, training and capacity building.\",\"url\":\"https:\/\/www.canva.com\/design\/DAFvG-uhEGo\/ljlMsVR0RtTWkAWIw1F01A\/view?utm_content=DAFvG-uhEGo&utm_campaign=designshare&utm_medium=link&utm_source=publishsharelink\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/59159ff0-8d97-451d-8bb1-c28ef754ed76\/mxW3ypoiWUyCxvBiSE05UcMTUp1hTYYXgi6Hnm3w.jpg\",\"title\":\"Wompreneur Network Initiative (Support community)\",\"altText\":\"It's our way of giving back to the society. The initiative gathers indigenous girls and women, especially widows, the unemployed, oppressed women, less privileged women, women living with disabilities, and single moms from across Africa. This is a support network that encourages and empowers these categories of women to discover their hidden potential, become entrepreneurs and financially independent through our mentoring sessions, free weekly training, as well as exposure to various jobs and money-making opportunities.   We represent the UN SDGs 1 (No Poverty), 5 (Gender equality) & 10 (Reduced Inequality) to build a better world for all women and girls. .\",\"url\":\" https:\/\/www.instagram.com\/wompreneurnetwork\/\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/5d7e945d-0acf-4143-a342-39cdf3b3f5a8\/7zhn2R1zmm6x01WtOI7goec4WyCs0IVQ4SRtUxMO.jpg\",\"title\":\"LBC Entertainment Podcast with Vivy K\",\"altText\":\"\",\"url\":\"https:\/\/podcasters.spotify.com\/pod\/show\/vivy-k\"}]}","{\"type\":\"text\",\"header\":\"Mini Profile \",\"data\":[{\"localHTML\":\"<p><strong>ABOUT LABELLE CONSULT LIMITED<\/strong><\/p><p>Our unique combination of consulting, knowledge, business, and sustainability makes our clients more resilient, drives impact and inspires trust. LaBelle Consult Limited was formed out of curiosity to implement sustainable development goals 1 and 8 by aligning our work to build capacity among businesses and individuals while contributing to economic growth. At <a href=\\\"https:\/\/www.canva.com\/design\/DAFrhaRsA0I\/rxtH9mmDkB6o7HqsBGd1Nw\/view?utm_content=DAFrhaRsA0I&amp;utm_campaign=designshare&amp;utm_medium=link&amp;utm_source=publishsharelink\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">LaBelle Consult<\/a>, we believe there is a more resourceful and valuable way to make an impact, which is why we boast of a pool of certified and selected experts through partnerships with accredited institutions in the USA, Germany, the Netherlands, and Nigeria and are still growing our collaboration network. Our passion to serve is obsessive, and we crave excellence during service. We focus on providing the best upskill training, business, and consulting services based on professionalism and expertise. We are excited to contribute positively to the further growth and development of individuals and businesses through our <a href=\\\"https:\/\/forms.gle\/jk1oZB3uLeFXHemm6\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">HR <\/a>consulting services (hiring, upskilling training, and capacity development) and procurement.<\/p><p><strong>OUR MISSION<\/strong><\/p><p>To have a seamless impact on all individuals and businesses by leveraging technology and all kinds of training to deliver excellent customer satisfaction.<\/p><p><strong>OUR VISION<\/strong><\/p><p>To achieve excellent and sustainable human capacity development across organizations in Nigeria and beyond.<\/p><p><strong>OUR CORE VALUES<\/strong><\/p><ul><li><p>Detail oriented<\/p><\/li><li><p>Sustainability driven <\/p><\/li><li><p>Building partnerships<\/p><\/li><li><p>Customer-centric<\/p><\/li><li><p>Unbeatable talents<\/p><\/li><li><p>Always there<\/p><\/li><li><p>Employee Empowerment <\/p><p><a href=\\\"https:\/\/www.googletagmanager.com\/ns.html?id=GTM-MK4WKW59\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/www.googletagmanager.com\/ns.html?id=GTM-MK4WKW59<\/a>\\\"<\/p><\/li><\/ul>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Make a Hire - Terms of service \",\"url\":\"https:\/\/docs.google.com\/document\/d\/1B80eCFa435y6k2_oBiwGR39nZ5vl2N0k\/edit?usp=sharing&ouid=115732248537362801891&rtpof=true&sd=true\"},{\"title\":\"Training and Capacity Development \",\"url\":\"https:\/\/forms.gle\/7K5BztTbYuSadgv79\"},{\"title\":\"Let's Collaborate \",\"url\":\"https:\/\/www.canva.com\/design\/DAFvG-uhEGo\/ljlMsVR0RtTWkAWIw1F01A\/view?utm_content=DAFvG-uhEGo&utm_campaign=designshare&utm_medium=link&utm_source=publishsharelink\"},{\"title\":\"Wompreneur Network Initiative Programs \",\"url\":\"https:\/\/forms.gle\/VwDmi4xCXvQUYjTe6\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/df9e18b1-8b42-408f-99ff-c2c8d428c276\/FIZzYNozMuhdDtPE2HB3Due10W4H1uXUmLbZ3iEV.jpg\",\"pageTitle\":\"LaBelle Consult Ltd\",\"bio\":\"We are an HR and business consulting company. We are a company that connects clients with properly trained, accountable, and qualified skilled workers, artisans, and professionals. We are registered, licensed, and fully operational in the FCT. Our services cover hiring, upskilling training, capacity development training, and procurement. For our training services, we offer a range of courses, from entrepreneurial and soft skill training to management courses and green skills training. All our courses, online and offline, come with internationally recognized certificates from our partner institutions and our certified partner consultants in the USA, Netherlands, Germany, and Nigeria as well. We represent the UN SDGs 1, 4, 5, 8, 10 and 17 through our company's work and have impacted young people since inception. In line with the SDGs that we represent, we run free virtual workshops and master class sessions on our Wompreneur Network Initiative platform as a social responsibility to give back to society. Here, we render free training on soft and entrepreneurial skills to indigenous women and girls across Africa who may not be able to afford paid training opportunities. We also share opportunities that expose them to work and earn while applying these acquired skills to their daily affairs.\\nWe also consult for startups and stabilize businesses and companies by constructing and developing sustainable HR structures and company policies suitable for their brand. We serve middle- and high-class earners, medium businesses, and companies looking for value, speedy service delivery and convenience in metropolises and urban areas.\\nWhile our major focus is HR Services\/Consulting\u2014hiring and training, we also run procurement projects on the supply of interiors like furniture and household electronics with branded manufacturers in Turkey and Nigeria as a form of regulating our artisans (like the interior architects, carpenters, and technicians) and what they supply to customers on request. We have built partnerships with wholesale manufacturing brands for furniture and interiors.\\nOn knowledge sharing, as part of our counseling and mentoring services, LaBelle Consult Ltd. also has a seasonal podcasting sector called LBC Entertainment Podcast, which airs recorded episodes on Spotify, Castbox FM, Google Podcasts, YouTube, Spreaker, and more. This mostly gives us an edge, makes us unique, and helps our cause in the service of humanity by showcasing our expertise in diversity.\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Whatsapp\",\"label\":\"whatsapp\",\"urlPrefix\":\"www.whatsapp.com\/\",\"value\":\"2348091303786\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"labelle_corp\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"labelleconsultltd@gmail.com\"},{\"id\":\"LinkedIn\",\"label\":\"linkedin\",\"urlPrefix\":\"\",\"value\":\"https:\/\/www.linkedin.com\/company\/labellecorp\/\"},{\"id\":\"Facebook\",\"label\":\"facebook\",\"urlPrefix\":\"www.facebook.com\/\",\"value\":\"labellecorp\"}],\"setTheme\":{\"selectedFont\":\"font-lively\",\"selectedColor\":\"disha-theme-purple-gradient\",\"selectedBorder\":\"border-default\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-light\",\"selectedBrand\":\"brandDisabled\",\"toggleVisitorsBg\":false},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"},\"tippings\":false,\"newUser\":false}","currency":"USD","country":"NG","industry":"[\"Branding\",\"Content creation\",\"Education\"]","is_discoverable":1,"is_payment_on":1,"has_products":true,"locale":"en","rave_islive":1,"rave_keys":"","created_on":"2023-03-23T09:30:05.000000Z","updated_on":"2023-11-04T21:53:16.000000Z"}