{"status":"success","username":"luvlybeeservices","page_id":32991,"firstname":"Luvlybee's Services By Blessing","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"video\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"url\":\"https:\/\/www.youtube.com\/embed\/I-PZg3A4y2U\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"Work with me directly\",\"url\":\"https:\/\/bit.ly\/Luvlybees\"},{\"title\":\"Work with me through Upwork\",\"url\":\"https:\/\/www.upwork.com\/workwith\/blessingenofe\"}]}","{\"type\":\"text\",\"header\":\"Hello! You must be tired from trying to handle all the content by yourself\u2026\",\"data\":[{\"localHTML\":\"<p><em>Yes! You already know you need quality content. But\u2026<\/em><\/p><ul><li><p><em>You and your team are quite busy trying to add value to your customers, to grow your business. So everyone in-house is too busy to write or create content.<\/em><\/p><\/li><li><p><em>You\u2019ve created content in the past, but it\u2019s not getting you results.<\/em><\/p><\/li><li><p><em>You\u2019ve got a content strategy and a plan, but need help to implement it.<\/em><\/p><\/li><li><p><em>You\u2019re not only looking for someone with digital communication skills, but someone creative enough to grab your audience's attention and use content to bring results.<\/em><\/p><\/li><li><p>You need help (virtual assistance) to cut down on your digital workload.<\/p><\/li><li><p><em>You also wish to specially celebrate a loved one's special day with either a customised note or a celebration content video, but don't have the time to create it.<\/em><\/p><\/li><\/ul><p><em>So, you need a creative quality content provider with mind-blowingly affordable freelance rates.<\/em><\/p><p><em>We should talk\u2026<\/em><\/p><p><em>I\u2019m <\/em><strong><em><a href=\\\"https:\/\/linkedin.com\/in\/blessing-enofe\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Blessing Enofe<\/a><\/em><\/strong><em>. And I\u2019m the face behind <\/em><strong><em><a href=\\\"https:\/\/linktr.ee\/luvlybee\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Luvlybee's Multidimensional Services<\/a>.<\/em><\/strong><\/p><p>\u2728I am a Digital creative communicator (focused on women-led businesses and sustainability-focused social impact organisations), who utilises creative storytelling and content creation to captivate your target audience and gain their trust. So that they take action, become willing clients and returning customers, thereby increasing your brand's productivity.<\/p><p>\ud83d\udc49\ud83c\udffdYou can work with me <a href=\\\"https:\/\/bit.ly\/Luvlybees\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">directly<\/a> or through <a href=\\\"https:\/\/www.upwork.com\/workwith\/blessingenofe\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">Upwork<\/a>.<\/p><p><\/p><ul><li><p><strong><u>WHY HIRE ME?<\/u><\/strong><\/p><\/li><\/ul><p>I believe that I am the best person you can find to meet the Digital Creative Communications needs you might have as a woman-owned business, people development brand and\/or a social impact organisation. Here's why.<\/p><p>I have always believed in using my God given gifts to impact many lives and there's no better way for me to do this than digital creative communications.<\/p><p>My goal is to help people live their best lives through the easily accessible, creative, edutaining and engaging content I create across the digital sphere. And to help promising brands get visibility on the internet in the process.<\/p><p>I am purpose-driven and goal-oriented. And so far, I have successfully assisted women-led businesses and sustainability-focused social impact organisations, B2B2C SaaS brands and individuals to scale their efforts in giving value across the internet by creating captivating and informative content, that helps them meet their end goals.<\/p><p><strong>What can I do for you and your brand?<\/strong><\/p><p>\u2022\u270d\ufe0f I can help you tell your brand story using creative super-engaging content that captivates your audience, makes them gain trust and fall in love with your brand, becoming willing clients\/customers as a result.<\/p><p>\u2022\u2728 I'll get this done through creative SEO-optimised content writing for your blog and other social media channels,<\/p><p>\u2022 \u270d\ufe0fUsing the well crafted content strategy and content calendar I would create for your brand,<\/p><p>\u2022 \u2728Through converting direct-response copies that utilise mesmerising storytelling for your email campaigns,<\/p><p>\u2022 \u270d\ufe0fVia designing learner-focused immersive media (XR) learning experiences (LxD) for self discovery<\/p><p>\u2022 \u2728Through micro-copies that engage your target audience and give them a great user experience while guiding them through using your site, app and\/or platform,<\/p><p>\u2022 \u270d\ufe0fThrough comics, 2d, 3d and whiteboard animations and slide videos that makes your audience crazy about you,<\/p><p>\u2022 And so much more...<\/p><p>Yes! I am adaptable to using diverse digital creative communication tools to help you swiftly achieve your end goal.<\/p><p>About my soft skills? Over the years, gotten feedback that I'm a long-term problem solver and a great team player who is organised, innovative, meticulous, honest, reliable, result-oriented, easy-going, accountable, empathetic, analytical, altruistic, cultured, and entrepreneurial. I am a good listener and an emotionally intelligent interpersonal communicator.<\/p><p>What drives me? Growth and development of potentials in diverse spheres. I am an advocate for people development, the Christian lifestyle, learning and wellness, XR, etc.<\/p><p>So, it's time to talk business. You agree with me, right? I'd like to connect with you. Feel free to click to <a href=\\\"https:\/\/bit.ly\/Luvlybees\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">contact me<\/a>. Cheers!\ud83e\udd42<\/p><p>Want to check out my previous freelance jobs? No worries.<\/p><p>Here's <a href=\\\"https:\/\/blessingenofe.journoportfolio.com\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">my writing portfolio<\/a><\/p><p>And <a href=\\\"https:\/\/behance.net\/blessingenofe\\\" target=\\\"__blank\\\" rel=\\\"noopener noreferrer nofollow\\\">my creative content portfolio<\/a>.<\/p>\"}]}","{\"type\":\"card\",\"header\":\"See what people I've worked with have to say.  \",\"subheader\":\"I am certain that you would also have amazing reviews to share. Let's work together.\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/e1a27ab3-11ef-4d4b-89c6-2ae7c341f958\/nsVK1J6RIdqKUUxeSGBLo9ZMXKTfIOHyPf8QWH9F.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/1af85128-2ba9-4783-9e81-4c3921781d2d\/sXuNJzaMiwLfO00LbBMFr0DhyJAMwd5hVrhsjViZ.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/7cc4d0c4-322c-460b-9d99-78cc65cca19e\/hL0U1cdX2TsZXu6HFwCjUJ4pLgRbLzhXjeDkUPWJ.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/069d3db3-7c3c-4e40-9a3c-d186da20a831\/6IWz8bih0Ktn5zx9PcrxBRjIXaBH42aKeW4jP1k7.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/20cea982-a3a7-445f-9d6a-9d61c8da5f19\/6OtNXO6O3hQEkvkA1FTCNtmDV82KKbWNtpmExf4M.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/d04b5751-c23c-4554-8709-0a06b44852f6\/qIpsoEJayYUqOPmnpR2uzrT8AbZnsnlP5mvTU67F.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/4f07a8ed-2778-40ea-9ebe-986972102a80\/xs1bWYDBc7on8jjBoOtcuLOdAnX5WejQjtVKhorT.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/e6b5bbd9-eef3-4c40-a363-b894897b8dec\/qtvm33nkTsiHaMaslTWB5lWr9kqdEjRgwFvRuD6Y.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/ae913b03-84b5-4d63-8347-45174ad505ef\/p4mh0uywEodp59nMfMvYCwcyTZjWxp6QmQ207LiT.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/eff3d2bf-5b0b-498f-871a-e890549ffa3e\/oiRpyU409R0H0GFgLMKhvT5H7b5YVzpa6PNy8Ldq.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/a5abe2a3-912e-41e8-82cb-6296c5c9a0b8\/Sjes1FCQXYU1oi8bqjQ4BcGfpKHbiGycHjrYG5cu.jpg\",\"title\":\"\",\"altText\":\"\",\"url\":\"\"},{\"image\":\"https:\/\/content.disha.ng\/pages\/e35685f1-106d-4813-bdc5-6e54db474ca3\/umH5HKym8noZg4cjCGk5bjtoW4FfeQISKVuV34pg.jpg\",\"title\":\"Click here. Let's do this!\",\"altText\":\"Click here. Let's do this!\",\"url\":\"https:\/\/bit.ly\/Luvlybees\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/ca73c286-8c37-4265-a2d8-06c65c813713\/XsWaRaDuWS0Nay4JODHsoy9bTUCuXhn0ZDJ9fZYP.jpg\",\"pageTitle\":\"Luvlybee's Services By Blessing\",\"phoneNumber\":\"\",\"bio\":\"Freelance Digital Creative Communicator||Digital Storyteller\/Content Development Specialist|Versatile SEO-\/Copy-\/UX-Writer|Content Designer|Providing Versatile Creative Virtual Assistance Services\\n\u2728I can help you to creatively tell your brand story, captivate & guide your audience till they take action. As well as reduce your digital workload as a busy executive and professional. All at affordable freelance rates.\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Email\",\"label\":\"email\",\"urlPrefix\":\"www.email.com\/\",\"value\":\"luvlybee.service@gmail.com\"},{\"id\":\"Telegram\",\"label\":\"telegram\",\"urlPrefix\":\"www.telegram.me\/\",\"value\":\"Luvlybee_services\"}],\"setTheme\":{\"selectedFont\":\"font-stylish\",\"selectedColor\":\"disha-theme-pink-gradient\",\"selectedBorder\":\"border-rounded\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-automatic\",\"selectedBrand\":\"brandEnabled\"},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"},\"tippings\":true}","currency":"USD","country":null,"industry":null,"is_discoverable":1,"is_payment_on":1,"has_products":true,"locale":"en","rave_islive":1,"rave_keys":"","created_on":"2022-06-22T11:02:47.000000Z","updated_on":"2024-04-16T02:18:31.000000Z"}