14+ Senior Product Designer & UX Analytic
Ksenia Titova-Plehotkina
14+ Senior Product Designer & UX Analytic
Education: Belarusian National Technical University - FITR
FACULTY INFORMATION TECHNOLOGICAL AND ROBOTICS RESEARCH AND EXPLORE АAUTOMATION OF TECHNOLOGICAL PROCESSES AND PRODUCTION
2000 – 2005
2000 – 2005
Studied: HMI (Human Manual Interface) For CNC Machine Industry And SCARA (Selective Compliance Articulated Robot Arm) Automatisation process and system
Courses: MBA Executive Director of Digital-Marketing
2021 – 2022
Knowledge: Revenue, AOV — Average Order Value, LCV — Lifetime Customer Value, Conversion, Bounces On The Purchase Page, DRR, Social Media, Email Analytics, CTR, CTA, CAC, K
Google UX Design Professional Certificate
2021 – 2022
Conduct UX Research and Test Early Concepts
Foundations of User Experience (UX) Design
Developing personas, user stories, and user journey maps
Conducting usability studies
Creating wireframes and prototypes
Testing and iterating on designs
Strong UX Skills
14+ years cross platform design developing for market place of B2C and B2B customers
Design And Supporting The Projects Over Across The Entire Lifecycle It.
Ability To Hear The Other Party, To Communicate Their Thoughts & Visualize Ideas. Ability To Deliver Solid Work On Tight Schedules. Experience In Handling Dev. Constraints.
Analytical Thinking With Looks Ahead. Outstanding Written And Verbal Communication Skills.
Expert Knowledge Of User-Centered Design Principles. Strong Sense Of Visual Design, Typography. Demonstrable Fluency With Sketch, Photoshop, Illustrator.
Practical skills
UX, Ability To Do Rapid Prototyping In Figma, Sketch, Invision
HTML, CSS With Ability Development CMS Bitrix, WordPress, Tilda, Magento, Modx And Joomla
Experience 14+
1,5 Years | Aug’21 — Until Now
"ZenOne"
2,8 Years | Okt’18 — Aug’21 Web Agency «Newsite»
12,4 Years | May’2006 — Aug’2018 Software development company «Belitsoft» Senior Product Designer Aug’2009 — Aug’2018
Senior Product Designer Product Design Web And Graphics Design Prototyping
2,8 Years | Okt’18 — Aug’21 Web Agency «Newsite»
Senior Product Designer Product Design Web And Graphics Design Prototyping
12,4 Years | May’2006 — Aug’2018 Software development company «Belitsoft»
Senior Product Designer Aug’2009 — Aug’2018
Product Designer Aug’2008 — Aug’2009
Graphic Designer May’2006 — Aug’2008
Develop Solution Business Processes (UX) & Services Solutions Media Design And Motion
Science: Academy of Science of Belarus
Academy of Science of Belarus
1,8 Years | Sept’2004 — Apr’2006
Practice Product Design, Analicical Science And Research Work Modeling And Design Of The Exterior Presentations And Motion
■ MY AWARDS
I’m proud that every mine work can be submitted to the competition
1RD PLACE Rating BAYNET '2020
BEST SERVICE AT TRAVEL AGENCY
«The Intercity»
«The Intercity»
2RD PLACE Rating BAYNET '2019
"BEST ONLINE STORE" AT AUTOHOLDING ATLANT-M
3RD PLACE Rating BAYNET' 2019
"CORPORATE SITE"AT AUTOHOLDING ATLANT-M
2RD PLACE Rating BAYNET '2019
«BESTLANDING» DESIGN LANDING FOR MODERN-CITY
1RD PLACE TIBO'2010
DESIGN «THE BOLSHOI OPERA AND BALLET THEATRE»
3RD PLACE TIBO'2010
VISUAL DESIGN: «DETYDETEY» POP GROUP
360° What's news in UX/UI principles
MBA Business Course. Director of Digital-Marketing 2022
Knowledge: Revenue, AOV — Average Order Value, LCV — Lifetime Customer Value, Conversion , Bounces on the purchase page, DRR, SocialMedia, Email analytics, CTR, CTA, CAC, Keywords that drive traffic, ROI/ROMI.
UX Book - Process and guidelines for ensuring a quality user experience
A beautiful customer journey tool made for modern journeys I know how important it is to create a shared understanding of the customer. I Use TheyDo to visualize customer journeys and see how the pieces of your work fit together.
International Standard ISO9241210 Part 210: Human-centred design for interactive systems
Human-centred design for interactive systems your idea, your users and a successful product launch. ideation user research user requirements User Stories, UI Design conception, UI management.
The basic of User Experience Design by interaction design foundation
One of you I know the daily challenges as a UXer in corporations only too well. UX Strategy & "Politics" UX process in the team No time & budget for proper research
Don't Make Me Think
I know how to turn the most complex development team into partners UX in Scrum, Global UX management, Proactive & communicative. When asked for your advice on a situation, you can just say 'I don't know, let me think more and get back to you.
For MVP my new project
Дни
Часы
Минуты
Секунды
For renew page
Дни
Часы
Минуты
Секунды
01
Creativity & innovation
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
03
Results maximization
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
03
Results maximization
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
02
Brand-first approach
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
04
Data-driven
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
04
Data-driven
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
insights
Business insights and articles written by our team of world-class professionals
An award-winning full-stack digital marketing studio
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
creativity
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
User reserch
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
Our Process
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
Our Team
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
which goals achievement
Key Jira
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Monthly visitors
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Work till
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Type
■ Fulfilment concept
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using ‘Content here, content here’, making it look like readable English. Many desktop publishing packages and web page editors
UX/UI Cases
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
problem brief It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using ‘Content here, content here’, making it look like readable English. Many desktop publishing packages and web page editors
UX/UI Cases
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
■ Fulfilment concept
Проснувшись однажды утром после беспокойного сна, Грегор Замза обнаружил, что он у себя в постели превратился в страшное насекомое.
Key Jira
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Monthly visitors
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Work till
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
UX/UI Cases
SAS & Services: Name
■ Fulfilment concept
The application allows brokers to keep track of apartments and additional information about them in one sentence with the convenience of an interface.
UX/UI Cases
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
■ Fulfilment concept
home, rent, building, broken, agent, housing, apartment, listing, map, finder, estate, real, realtor, app, mobile
Key Jira
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Monthly visitors
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Work till
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using ‘Content here, content here’, making it look like readable English. Many desktop publishing packages and web page editors
UX/UI Cases
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
■ Fulfilment concept
Проснувшись однажды утром после беспокойного сна, Грегор Замза обнаружил, что он у себя в постели превратился в страшное насекомое.
Key Jira
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Monthly visitors
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Work till
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using ‘Content here, content here’, making it look like readable English. Many desktop publishing packages and web page editors
UX/UI Cases
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
Key Jira
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Monthly visitors
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Work till
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using ‘Content here, content here’, making it look like readable English. Many desktop publishing packages and web page editors
UX/UI Cases
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
Monthly visitors
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Key Jira
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Work till
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
UX/UI Product Design
■ concepts
Product:User Experience, Business analytics, Journey map, Features, Innovations
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
Monthly visitors
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Key Jira
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Work till
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
Назад
Далее
■ Fulfilment concept
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using ‘Content here, content here’, making it look like readable English. Many desktop publishing packages and web page editors
UX/UI Cases
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
■ Fulfilment concept
UX/UI Cases
■ Fulfilment concept
SAS & Services: User friendly Interface the first. Features, Innovations – LevelUP User Experience
Daily routine
■ concepts
Mast have design: Any design have roles, separated for types
Design Guide, Ui.Kit
Design product motion with ui kit containing components, baseline UIs, navitransitions.
🔒 Have a lock objects are protected by copyright
Vector for web
Design an illustrations are an example or a biggest story which is used to make a point clear.
🔒 Have a lock objects are protected by copyright
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
How complex can a login page be? — The login page design of an enterprise product
As a UX designer, or a UX designer to-be, do you remember the first time you design a login flow? Shorten the required steps is usually regarded as the “guidance” of a design, but why are still many login processes are like the pain in the neck? I recalled my first time designing a login page as a UX practice, it was such a “comfortable” experience. I put two input boxes at the centre of the frame and a submit button below. Even the “forget password” handling flow seems so natural. A year after, my thought of the login page changes when I got my first Login task at work: a login page for an enterprise cybersecurity product Like all enterprise product designs, the design focus is not only to create the experience of the provided feature itself, but also to fit into the customer’s ecosystem, and most importantly, to solve the security concerns. Usability is still one of the top priorities from the UX design perspective, but we might need a bit trade-off to meet the requirement of the solution
...
Fit into the ecosystem
Have you thought about, why in some login page, the account and password input boxes are on the same page, but in other platforms are separated into two steps? When we sign up for a product, we create an identity on it that we can regard as a “local account.” However, most enterprises have used Identity and Access Management (IAM), which allows them to manage their assets and employers’ identity from accessing multiple products or services. With IAM integration, a user does not need to sign up for all the products for access, it is possible to sign in with the same account. That is, the user using their IAM account will be redirected to Single Sign-On (SSO) page to complete the login process.
The main purpose of a login page is to identify whether an account is valid to access. Imagine the local accounts and IAM accounts are stored in two separated tables, each table maps the account with the password and its access permission. How does the system know which table to check? This leads to the complex login process of an enterprise product.
A couple of user flows are commonly seen in the enterprise login page design.
User-self declaration & System verification
Some of the login pages require the user to select the account type before inputting the account. The system then can map to the corresponded table for the identity information. However, the experience strongly relies on the user’s knowledge. A user may not be fully aware of their account type while signing into a console, a knowledge-based mistake then happens. The instruction and the error handling, in this case, is crucial to direct the user to the right attempt.
...
Another common login design is to verify the account type by the system. When a user inputs their account, the system will verify if the account is an account from the integrated third-party IAM. This avoids the user’s mistake from selecting the incorrect account type, as long as they input the account correctly.
Human error: an important ingredient in great designs
Let’s go over the types of errors we make, what causes them, what are the strategies for correcting errors and last but not least how to design for errors.
Disclaimer: the term system is used loosely to describe digital products, flows, actual systems, etc.
I'm proud that every mine work can be submitted to the competition
My awards
1RD PLACE
Rating BAYNET'2020
Best service at «The Intercity» Travel agency
2RD PLACE
Rating BAYNET'2019
"BEST ONLINE STORE" at AutoHolding ATLANT-M
3RD PLACE
Rating BAYNET'2019
"Corporate Site"at AutoHolding ATLANT-M
2RD PLACE
Rating BAYNET'2019
«BestLanding» Design Landing for Modern-City
1RD PLACE TIBO'2010
Design «The Bolshoi Opera and Ballet Theatre»