{"status":"success","username":"iamara","page_id":23351,"firstname":"Ogechukwu Amarachi Confidence","subscription":"{\"status\":\"free\",\"expiration_date\":null,\"can_trial\":true}","elements":["{\"type\":\"text\",\"header\":\"UI\/UX Product Designer\",\"data\":[{\"localHTML\":\"<p><strong>Welcome to my space!<\/strong><\/p><p>I am <strong>Ogechukwu Amarachi<\/strong> a <strong>UI\/UX Product Designer<\/strong> based in <strong>Lagos<\/strong>, <strong>Nigeria.<\/strong> The goal is to design awesome digital interfaces that are simple to use and provide an excellent user experience. To study and improve user experience and engagement, I employ effective research methods, well-thought-out strategies, and innovative designs. I'm good at emphatically listening to and studying user attitudes and behaviors in order to create useable and valuable products that satisfy the needs of both producers and customers.<\/p><p>When I'm not designing digital products, I'm reading to expand my knowledge and fight ignorance. Reading, I feel, is the first step.<\/p><p>Use the links below to learn more about what I do.<\/p>\"}]}","{\"type\":\"button\",\"data\":[{\"title\":\"DESIGN PORTFOLIO (BEHANCE)\",\"url\":\"http:\/\/Behance.net\/ogechukamarach\"},{\"title\":\"DESIGN PORTFOLIO (DRIBBLE)\",\"url\":\"https:\/\/dribbble.com\/heymimi57\"},{\"title\":\"Investa App \",\"url\":\"\"},{\"title\":\"RESUME\",\"url\":\"https:\/\/drive.google.com\/file\/d\/1ucMfZ-foV6sDCfnZnLKYYxz_xEPUNCbz\/view?usp=sharing\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/b77599e5-8ad2-4b5a-8924-7bae761bdb66\/kRlm2KynKm7VaXOk1AOTngc5VwDmdBXq81crztg6.jpeg\",\"title\":\"An overview of my Fruity App\",\"altText\":\"A brief description of the various pages of my fruity app. The full view is just a tap away.\",\"url\":\"https:\/\/www.behance.net\/gallery\/111303605\/Mimi-Fruity-App-Case-Study\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/62286f03-e5e8-413f-9cf8-a6e67f8cd37f\/UgOFipw03nJyMfDohI2q0Jfd6Tict6a8mfvFJJA4.jpg\",\"title\":\"Findnany Case Study\",\"altText\":\"A full detail of the processes used in designing the babysitter\/nanny (Findnany) Web application\",\"url\":\"https:\/\/www.behance.net\/gallery\/143150767\/BabysitterNanny-Web-Application-UIUX-case-study\"}]}","{\"type\":\"card\",\"header\":\"\",\"subheader\":\"\",\"data\":[{\"image\":\"https:\/\/content.disha.ng\/pages\/52182546-0e06-4139-be87-24d8158bcaa2\/tCOc7Dz5lIQWOmV34cLA6vo6sdGLLoPiB7Peae0N.png\",\"title\":\"Investa App Redesign\",\"altText\":\"Casestudy on the processes used to improve millennial's ability to save and be retained on the investa app\",\"url\":\"\"}]}"],"settings":"{\"profileImage\":\"https:\/\/content.disha.ng\/pages\/deabb058-5e13-4f3c-86c0-504ffda2c37e\/pWCaa5Ksb4d7Rb7lXShYhi1VGkOLusRyzr8VFvjt.jpeg\",\"pageTitle\":\"Ogechukwu Amarachi\",\"bio\":\"UI\/UX Product Designer | Passionate about Tech | Proactive Chemist | Sociable.\",\"userStatus\":\"newUser\",\"socialLink\":[{\"id\":\"Whatsapp\",\"label\":\"whatsapp\",\"urlPrefix\":\"www.whatsapp.com\/\",\"value\":\"2347069179422\"},{\"id\":\"Twitter\",\"label\":\"twitter\",\"urlPrefix\":\"www.twitter.com\/\",\"value\":\"iamaraah\"},{\"id\":\"Dribbble\",\"label\":\"dribbble\",\"urlPrefix\":\"www.dribbble.com\/\",\"value\":\"heymimi57\"},{\"id\":\"Behance\",\"label\":\"behance\",\"urlPrefix\":\"www.behance.net\/\",\"value\":\"ogechukamarach\"},{\"id\":\"LinkedIn\",\"label\":\"linkedin\",\"urlPrefix\":\"\",\"value\":\"https:\/\/www.linkedin.com\/in\/ogechukwu-amarachi\/\"}],\"setTheme\":{\"selectedFont\":\"font-lively\",\"selectedColor\":\"disha-theme-pink-gradient\",\"selectedBorder\":\"border-rounded\",\"selectedEdge\":\"edgeEnabled\",\"selectedBackground\":\"background-dark\",\"selectedBrand\":\"brandEnabled\"},\"setScripts\":{\"googleAnalytics\":\"\",\"facebookPixels\":\"\"},\"phoneNumber\":\"\"}","currency":null,"country":null,"industry":"[\"UI\/UX\",\"Technology\",\"Web design\",\"Portfolio\"]","is_discoverable":1,"is_payment_on":1,"has_products":false,"locale":"en","rave_islive":0,"rave_keys":"","created_on":"2020-12-09T19:45:50.000000Z","updated_on":"2024-01-08T22:03:11.000000Z"}