{"status":"success","username":"iamthedella","page_id":3413,"firstname":"Abayomi Adeola (Della)","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"payout_link\":true,\"name\":\"Donate to funding Education for Children\",\"description\":\"For every N2,000 you give, you give children the opportunity to access educational materials across different countries in Africa.\",\"price\":\"2000\",\"fulfilment_note\":\"Thank you so much for your donation! You are the reason a child would smile. God bless you!\",\"fulfilment_url\":\"\",\"currency\":\"NGN\",\"type\":\"product\"}","{\"type\":\"text\",\"header\":\"Life and Business Coach \u2022 Equipper \u2022 Visionary Leader \u2022 Executioner \u2022 A Warrior Queen on an Assignment\",\"data\":[{\"localHTML\":\"<p>\u27a1\ufe0fAs a Life and Business Coach, I help young people redefine their lives, awake a sense of purpose, lead them to manage and execute their God given ideas without fear, build great relationships<\/p><p>\u27a1\ufe0fAs a Social Savior, I lead the team at Evolufy Africa, a multi-tiered nonprofit organization that\u2019s at the intersection of Education and General well-being of children, trainings and community for changemakers in Africa and the Technology Education for Teenagers and Secondary school students.<\/p><p>\u27a1\ufe0fAs a minister, I help young people build their relationship with God, be rooted and planted in the word and prayer to ignite their devotion to God. I provide systems to fire up consistency and fervency in their intimacy with God, transformation and strength in conviction as well as living out a life of purpose.<\/p><p>\u27a1\ufe0f As a Product Manager, I help companies and organizations manage and develop their people, projects and products with strategic direction through actionable research and long-term roadmaps so that they can stand out in their industry and generate consistent revenue. I have worked with reputable brands to identify what their customer needs are and develop must-have Products and Projects from initiation to maintenance.<\/p><p>\u27a1\ufe0f As a Serial Entrepreneur, I have started and led multiple business ventures over the course of my career. I seek new opportunities, launch new ventures, and not bound to a specific industry or market so I provide solutions across furniture, interior design, customized merch, bookshop and household items.<\/p><p><\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Pick my brain for your idea! \",\"url\":\"https:\/\/paystack.com\/pay\/bookacall\"},{\"title\":\"Get my Books; Birthday Book Sales!\",\"url\":\"https:\/\/paystack.com\/pay\/buymybooks\"},{\"title\":\"Send Your Prayer Requests\",\"url\":\"https:\/\/gdpd.xyz\/iamthedella\"},{\"title\":\"Get my Audio Letters\",\"url\":\"https:\/\/mailchi.mp\/f3ce1948389e\/audio-letters\"},{\"title\":\"Take a Personality Test\",\"url\":\"https:\/\/www.truity.com\/test\/personal-strengths-inventory\"},{\"title\":\"Grab my Books and Resources\",\"url\":\"http:\/\/wa.me\/2347052606890\"},{\"title\":\"Read my Blog \",\"url\":\"http:\/\/www.abayomiadeoladella.com.ng\"}]}","{\"type\":\"card\",\"header\":\"More \ud83c\udf89 \",\"subheader\":\"Just something about me and events.\ud83e\udd42\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/6a3e313c-5aa1-4f44-9a48-60c71bf1a3da\/dH0JKOQXONaMW1VcQxxbW5dW3uAB6TXY6wNhqNHK.png\",\"title\":\"A bit about me.\",\"url\":\"http:\/\/www.dellasdiary.com.ng\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/1fb6f21a-aa16-4053-91f5-7ea9ddf17f59\/YqW64NCFjoRAIxi6JT4LJFxgnNQxt2YfjB98YpS8.jpeg\",\"title\":\"Breeze Out with Della\",\"altText\":\"An outdoor hangout to meet new people, talk, eat and just breeze out!\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/b518750b-9d94-4b63-a622-cace2502e198\/39sMWAxlcOvPobUw77aGKilXdnlFwUvCIsSLCfBt.jpg\",\"title\":\"Associate Member of WIMBIZ\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/acaeda64-588f-4035-9498-c0b3d8f59d3c\/fUOiYFkehgHzEbIzJ6sVXmBBwcnHJuKUXl5zd8yc.jpg\",\"title\":\"Public Speaker\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/a0ce3107-0a2f-4b22-a763-650f7d097f94\/vlsLN4XgGfdjWDTUlNZnX3TiWQeyAxvcX0ZdlkqA.jpeg\",\"title\":\"Social Butterfly \",\"altText\":\"\",\"url\":\"\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/36fc21ac-61b5-45ca-ba56-b90aba9059af\/2MbTXsTDVPwhKKT3cnmgJTh6ajGMmUUOewKU5cnZ.jpeg\",\"pageTitle\":\"Abayomi Adeola Della\",\"bio\":\"I am a Life and Business Coach. I help people redefine their lives and give them a sense of purpose, thereby leading them to manage their God given ideas without fear, building great relationships, generating fresh ideas, and executing them with great success. Email me here: speakwithdella@gmail.com\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"speakwithdellagmail.com\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"iamthedella\"},{\"id\":\"YouTube\",\"label\":\"youtube\",\"urlPrefix\":\"www.youtube.com\/\",\"value\":\"Adeola Abayomi (The Chat with Della)\"},{\"id\":\"Instagram\",\"label\":\"instagram\",\"urlPrefix\":\"www.instagram.com\/\",\"value\":\"iamthedella\"}],\"setTheme\":{\"selectedFont\":\"font-simple\",\"selectedColor\":\"disha-theme-default\",\"selectedBorder\":\"border-normal\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-dark\",\"selectedBrand\":\"brandEnabled\",\"toggleVisitorsBg\":false},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"}}","currency":"NGN","country":null,"industry":"[\"Content creation\",\"Education\",\"Fashion\",\"Technology\"]","is_discoverable":1,"is_payment_on":0,"has_products":true,"locale":"en","rave_islive":1,"rave_keys":"","created_on":"2020-03-05T19:05:15.000000Z","updated_on":"2024-04-23T01:00:21.000000Z"}