{"status":"success","username":"victoriamadedor","page_id":18416,"firstname":"Victoria Madedor","subscription":"{\"status\":\"free\",\"expiration_date\":null}","elements":["{\"type\":\"text\",\"header\":\"Welcome \ud83c\udf89\",\"data\":[{\"localHTML\":\"<p>Victoria holds a B.Agric in Agricultural Economics from the University of Benin, Edo State, Masters in Business Administration (MBA) and currently pursuing Masters in Marketing and Innovation (MA) at the Metropolitan School Of Business UK . She is an experienced Business Development Consultant with a focus on the Agricultural Sector While Victoria\u2019s previous roles had a leaning towards Information Technology, upon joining BOI-ITC, her passion for the agro-allied sector was re-ignited as she began to work on developing the businesses of SME\u2019s in that sector. In other to successfully understand the SME space she has undergone several trainings with London Business School (MOOC), Lagos Business School, Metropolitan School Of Business UK, and Centre for Development Innovation, Wageningen UR Netherlands<\/p><p>She is currently the Agribusiness Expert at BOI Investment and Trust Company, a subsidiary of the Bank of Industry Nigeria, a Fellow Institute of Management Consultants (FIMC), a Senior Member Chartered Institute of Public Diplomacy and Management, and Fellow Institute of Agribusiness Management Nigeria. Her passion for youth and women development has prompted her to volunteer as mentor for Google Accelerator Launch Pad (2017), Lagos State Government Ready Set Work Program (2017), International Business Accelerator (2018), which has improved the lives of over 82 youths and women. <\/p><p>She has worked as Resource person for Post-Harvest Loss Alliance for Nutrition (PLAN), TLS services Ltd, Edo Women for Agriculture and Enterprises to mention a few, Lagos State Ministry of Health and Environment, Lagos State Ministry of Agriculture, Lagos State Ministry of Education. She is an advocate for Agribusiness growth in Nigeria and a subject matter Speaker.<\/p><p>She currently sits as Board adviser for Umuebe Farms Ltd, Braval Apparel Nig. Ltd, Lexcel Plastics and Products Ltd, Edo Women for Agriculture and Enterprises, ANDA Ltd (Ghana) and Freeway Farms Nig. Ltd. <\/p><p>Victoria is the Initiator of SlumInclusion, an advocacy program aimed at financially including youths that are vulnerable and disadvantaged in Nigeria through Agribusiness schemes. She is co-initiator of the SupportforAfricaSMEs aimed at propagating hope to entrepreneurs\u2019 during the COVID-19 by sharing their stories of innovation, creativity, struggles and successes on social media.<\/p>\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/efa02573-e9d9-4e36-8e2d-17b92d2c596f\/4UwA1znJ8IFDuss4ySakSQe0fvQslZivUJBwf1mr.jpeg\",\"title\":\"Image 1\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/22c04862-9f7d-489e-8105-2f0f7745829b\/t1jE3pL11nNltLhUSXc4o94XJcZCgIAXZ3Tyata4.jpeg\",\"title\":\"Image 2\",\"url\":\"https:\/\/your-link.com\"}]}","{\"type\":\"text\",\"header\":\"COVID-19- UNLOCKING DIGITAL OPPORTUNITIES IN AGRICULTURE AND AGRIBUSINESS\",\"data\":[{\"localHTML\":\"<p>In Africa, we are all waking up to appreciate the value and benefits that the long underrated agricultural sector brings in respect to the survival of general population in wake of the COVID 19 pandemic.<\/p><p>Daily, we are witnessing a growing momentum in the scramble to purchase foodstuff by households vis-\u00e0-vis the availability of products produced locally, as many nations have closed both their land and air borders in efforts to contain the spread of the virus. Expectedly, international travel and trade have taken big hits along with the adverse impacts of food imports among others causing unanticipated food supply chain disruptions and shortages in meeting local growing food demands. These events have created a domino effect is forcing many developing countries especially in Africa to take a nationalistic approach towards addressing and ring-fencing food productivity and security for their citizens; hence paving new grounds for the rebirth of Agriculture in the continent.<\/p><p><\/p><p>Read more:<\/p><p><a href=\\\"https:\/\/www.linkedin.com\/pulse\/covid-19-unlocking-digital-opportunities-agriculture-madedor-\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/www.linkedin.com\/pulse\/covid-19-unlocking-digital-opportunities-agriculture-madedor-\/<\/a><\/p>\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/2def1b86-7acf-48ff-8e14-b1e751119754\/eKSLImPtIdpHOHR88gGeUAWaqKK0zxMWetX6rNTO.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"text\",\"header\":\"MY EXPERIENCE AT THE INTERNATIONAL CEO ECONOMIC SUMMIT: Going beyond funding.\",\"data\":[{\"localHTML\":\"<p>In July, 2019), I attended the international CEO\u2019s Economic summit in Brussels, and it was a lovely and mind-opening experience. The ICES is a global platform designed, under the International CEO Forum (ICF), to foster international trade and investment, promote business partnerships among leading business institutions from across the globe. The deliberations, panel meetings, and investment round tables which played out with economic leaders from 59 countries spread across the globe was a particularly productive and enlightening experience. In this short piece, I concisely capture the lessons I learned during the summit and how they may affect agribusiness in Nigeria.<\/p><p><\/p><p>Read more:<a href=\\\"https:\/\/www.linkedin.com\/pulse\/my-experience-international-ceo-economic-summit-going-madedor-\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/www.linkedin.com\/pulse\/my-experience-international-ceo-economic-summit-going-madedor-<\/a><\/p><p><\/p>\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/4d57f326-68c6-432d-beb7-9d67f5988b9d\/G8HWHocxoR2XTF3vpC9mPZpJbj13WozFMmSzwhmn.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"text\",\"header\":\"My Experience As Board Adviser- Poultry Farm\",\"data\":[{\"localHTML\":\"<p>Three years ago, I joined the advisory board of an organization to revive its moribund poultry farm. Today, the farm boasts of a bird capacity of 180,000 with 92% livability and 91% egg dropping. With the increased demand for its packed eggs, the farm intends to expand its capacity while including broilers in its operations. This level of productivity was partly achieved by adapting poultry technology to meet the peculiarities of local birds.<\/p><p>Also, the management of the farm are the most intentional personnel I have ever known. I say this with so much delight as they averted all losses during the five months glut season experienced in 2019 with strategies that drove demand of eggs within that region.<\/p><p>Read more:<\/p><p><\/p><p><a href=\\\"https:\/\/www.linkedin.com\/pulse\/my-experience-board-adviser-poultry-farm-1-victoria-madedor-\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/www.linkedin.com\/pulse\/my-experience-board-adviser-poultry-farm-1-victoria-madedor-\/<\/a><\/p><p><\/p>\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/82c0c6ab-1856-4f50-8a02-5f7c8ea28bcf\/66rqBoxwnoBGenPB9eEgvcRoSuGk8EqUjgT7Bp6W.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"text\",\"header\":\"My Experience as a Board Adviser II: - Understanding the Difference Between Writing & Execution of Poultry Business Plan.\",\"data\":[{\"localHTML\":\"<p><strong>My Experience as a Board Adviser II: - Understanding the Difference Between Drafting a Business Plan &amp; its Execution.<\/strong><\/p><p>In 2019, I was privileged to visit several moribund farms in the South-West region of Nigeria of different flock sizes. My interactions with the promoters of these farms showed their limited understanding of the cash-flow cycle and its role in sustaining the operations of the farm. Most of them sourced their plans from the web usually with the expectations of a quick Return on Investment (ROI) while leaving out the need for continuous cash-flow required for operating activities.<\/p><p><\/p><p>Read more:<\/p><p><a href=\\\"https:\/\/www.linkedin.com\/pulse\/my-experience-board-adviser-ii-understanding-between-madedor-\/\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">https:\/\/www.linkedin.com\/pulse\/my-experience-board-adviser-ii-understanding-between-madedor-\/<\/a><\/p><p><\/p>\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/2bb3e776-0afb-4052-b9ea-cc603a93cfe5\/KHv7T5gMviEjZEr6ojI7bXAkkf43L4og7ufrNVNA.jpeg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Read more of my content \ud83d\ude4c\ud83c\udffd\u2764\ufe0f \ud83d\udc4d\",\"url\":\"\"},{\"title\":\"AgricWatch Personality Of The Week: Victoria Madedor\",\"url\":\"https:\/\/agricwatch.com\/agricwatch-personality-of-the-week-victoria-madedor\/\"},{\"title\":\"Madedor: Nigerian farmers are the heroes of COVID-19 pandemic\",\"url\":\"https:\/\/www.thecable.ng\/madedor-nigerian-farmers-are-the-heroes-of-covid-19-pandemic\"},{\"title\":\"The African farmers\u2019 stories: The gentle farmer\",\"url\":\"https:\/\/businessday.ng\/agriculture\/article\/the-african-farmers-stories-the-gentle-farmer\/\"},{\"title\":\"Abu\u2019s Market partners to tackle hunger amid coronavirus spread\",\"url\":\"https:\/\/businessday.ng\/agriculture\/article\/abus-market-partners-to-tackle-hunger-amid-coronavirus-spread\/\"},{\"title\":\"Returnable plastic creates major solution to $9bn post-harvest losses\",\"url\":\"https:\/\/businessday.ng\/agriculture\/article\/returnable-plastic-creates-major-solution-9bn-post-harvest-losses\/\"},{\"title\":\"https:\/\/businessday.ng\/agriculture\/article\/covid-19-unlocking-digital-opportunities-in-agriculture-and-agribusiness\/\",\"url\":\"https:\/\/businessday.ng\/agriculture\/article\/covid-19-unlocking-digital-opportunities-in-agriculture-and-agribusiness\/\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/9012a0ff-813f-4374-81c5-f11fba951572\/KW2cF3InaJgPUZnC3hIrNJSREA09SNtfiOswEAXx.jpeg\",\"pageTitle\":\"Victoria Madedor\",\"bio\":\"Business Development |Account Management|Project Management| Agribusiness Specialist (CMC, FIMC, FIAMN)\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Whatsapp\",\"label\":\"whatsapp\",\"urlPrefix\":\"www.whatsapp.com\/\",\"value\":\"2348023456789\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"madedorvictoria\"},{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"Vickiejiro@gmail.com\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"MadedorVictoria\"},{\"id\":\"LinkedIn\",\"label\":\"linkedin\",\"urlPrefix\":\"\",\"value\":\"https:\/\/www.linkedin.com\/in\/victoria-madedor-331708b7\/\"}],\"setTheme\":{\"selectedFont\":\"font-bold\",\"selectedColor\":\"disha-theme-default\",\"selectedBorder\":\"border-rounded\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-dark\",\"selectedBrand\":\"brandEnabled\",\"toggleVisitorsBg\":false},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"}}","currency":null,"country":null,"rave_islive":0,"rave_keys":null,"created_on":"2020-09-06T20:37:48.000000Z","updated_on":"2021-11-26T04:26:56.000000Z"}