ਇਸ ਗਾਈਡ ਤੋਂ ਸਿੱਖੋ ਕਿ ਕਿਵੇਂ ਇੱਕ ਮੋਬਾਈਲ ਐਪ ਯੋਜਨਾ ਬਨਾਉਣੀ, ਬਣਾਉਣੀ ਅਤੇ ਸੁਧਾਰਨੀ ਹੈ ਜੋ ਸਮਾਰਟ ਨੋਟੀਫਿਕੇਸ਼ਨ ਅਤੇ ਰਿਮਾਈਂਡਰ ਭੇਜੇ—ਟਾਈਮਿੰਗ, ਨਿਜੀਕਰਨ, UX ਪੈਟਰਨ ਅਤੇ ਪ੍ਰਾਈਵੇਸੀ ਉੱਪਰ ਧਿਆਨ ਨਾਲ।

ਇੱਕ ਸਮਾਰਟ ਨੋਟੀਫਿਕੇਸ਼ਨ ਐਪ ਦਾ ਮਤਲਬ "ਹੋਰਨ ਨੋਟੀਫਿਕੇਸ਼ਨ" ਨਹੀਂ ਹੈ। ਇਸਦਾ ਮਕਸਦ ਘੱਟ ਪਰ ਵਧੀਆਂ-ਸਮੇਂ ਵਾਲੀਆਂ ਸੁਝਾਵਾਂ ਦੇ ਕੇ ਲੋਕਾਂ ਨੂੰ ਉਹ ਕੰਮ ਪੂਰਾ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਨਾ ਹੈ ਜਿਸ ਦੀ ਉਹ ਪਹਿਲਾਂ ਹੀ ਪਰਵਾਹ ਕਰਦੇ ਹਨ—ਉਹਨਾਂ ਨੂੰ ਰੋਕੇ ਬਿਨਾਂ।
ਸਕ੍ਰੀਨ ਡਿਜ਼ਾਈਨ ਜਾਂ ਟੂਲ ਚੁਣਨ ਤੋਂ ਪਹਿਲਾਂ, ਆਪਣੇ ਉਤਪਾਦ ਲਈ "ਸਮਾਰਟ" ਦੀ ਸਧਾਰਨ ਪਰਿਭਾਸ਼ਾ ਲਿਖੋ। ਇੱਕ ਪ੍ਰਯੋਗਤਮਿਕ ਵਰਜਨ ਇਹ ਹੈ:
ਜੇ ਤੁਸੀਂ ਇਹ ਨਹੀਂ ਬਤਾ ਸਕਦੇ ਕਿ ਯਾਦ ਦਿਵਾਉਣ ਵਾਲੀ ਸੂਚਨਾ ਹੁਣ ਕਿਉਂ ਭੇਜੀ ਜਾ ਰਹੀ ਹੈ, ਤਾਂ ਇਹ ਹਾਲੇ ਸਮਾਰਟ ਨਹੀਂ ਹੈ।
ਜਿਆਦਾਤਰ ਰਿਮਾਈਂਡਰ ਐਪ ਪਹਿਲਾਂ ਇੱਕ-ਦੋ ਕਿਸਮਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ ਅਤੇ ਜਿਵੇਂ ਸਿਖਦੇ ਹਨ ਵਧਦੇ ਹਨ।
ਮੁੱਖ ਗੱਲ ਹੈ ਇਕਸਾਰਤਾ: ਹਰ ਰਿਮਾਈਂਡਰ ਕਿਸਮ ਦੀ ਭਵਿੱਕ-ਕਿਰਿਆ (ਸਨੂਜ਼, ਰੀ-ਸ਼ੈਡਿਊਲ, ਕੰਪਲੀਟ) ਪੇਸ਼ਗੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਤਾਂ ਜੋ ਯੂਜ਼ਰ ਐਪ 'ਤੇ ਭਰੋਸਾ ਕਰਨ।
"ਇੰਨਗੇਜ਼ਮੈਂਟ" ਅਸਪਸ਼ਟ ਹੈ। ਐਸੇ ਮੈਟਰਿਕ ਚੁਣੋ ਜੋ ਦਰਸਾਉਣ ਕਿ ਰਿਮਾਈਂਡਰ ਵਾਸਤਵ ਵਿੱਚ ਮਦਦਗਾਰ ਨੇ:
ਇਹ ਮੈਟਰਿਕ ਦੇਸੀਜ਼ਨਾਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨਗੀਆਂ—ਜਿਵੇਂ ਡਿਫੌਲਟ ਸ਼ਡਿਊਲ, ਸ਼ਾਂਤ ਘੰਟੇ ਅਤੇ ਕਾਪੀ।
ਜੋ ਤੁਸੀਂ ਬਣਾ ਰਹੇ ਹੋ ਉਸ ਦੇ ਨੁਸਖੇ ਮੁਤਾਬਕ iOS, Android, ਜਾਂ cross-platform ਚੁਣੋ—ਸਿਰਫ ਡਿਵੈਲਪਰਸ ਦੀ ਆਸਾਨੀ ਲਈ ਨਹੀਂ। ਪਲੇਟਫਾਰਮ ਨੋਟੀਫਿਕੇਸ਼ਨ ਵਿਹਾਰ ਵਿੱਚ ਫਰਕ ਹੁੰਦਾ ਹੈ (ਪਰਮੀਸ਼ਨ ਪ੍ਰੰਪਟ, ਡਿਲਿਵਰੀ ਨਿਯਮ, ਗਰੂਪਿੰਗ), ਇਸ ਕਰਕੇ ਇਹਨਾਂ ਫਰਕਾਂ ਲਈ ਯੋਜਨਾ ਬਣਾਓ।
ਇੱਕ ਵਾਕ ਵਿੱਚ ਲਿਖੋ ਜੋ ਤੁਸੀਂ app store ਲਿਸਟਿੰਗ ਵਿੱਚ ਰਖ ਸਕੋ। ਉਦਾਹਰਨਾਂ:
ਉਹ ਵਾਕ ਫੀਚਰ ਰਿਕੁਐਸਟਾਂ ਲਈ ਫਿਲਟਰ ਬਣ ਜਾਂਦਾ ਹੈ: ਜੇ ਇਹ ਵਾਅਦੇ ਨੂੰ ਮਜ਼ਬੂਤ ਨਹੀਂ ਕਰਦਾ, ਤਾਂ ਸ਼ਾਇਦ ਇਹ ਫੇਜ਼ ਦੋ ਦੀ ਚੀਜ਼ ਹੈ।
ਇੱਕ ਰਿਮਾਈਂਡਰ ਐਪ ਤਦ ਜ਼ਿਆਦਾ ਸਫਲ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇਹ ਅਸਲੀ ਰੁਟੀਨਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ—ਨਾ ਕਿ ਵਧੇਰੇ ਸੈਟਿੰਗਜ਼ ਦੇ ਪੇਸ਼ਕਸ਼ ਨਾਲ। ਨੋਟੀਫਿਕੇਸ਼ਨ ਸ਼ਡਿਊਲਿੰਗ ਲਾਜਿਕ ਜਾਂ ਪੁਸ਼ ਡਿਜ਼ਾਈਨ ਚੁਣਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਤੈਅ ਕਰੋ ਕਿ ਤੁਸੀਂ ਕਿਸ ਦੀ ਮਦਦ ਕਰ ਰਹੇ ਹੋ, ਉਹ ਕੀ ਹਾਸਲ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ, ਅਤੇ ਉਨ੍ਹਾਂ ਲਈ "ਸਫਲਤਾ" ਕੀ ਹੈ।
ਕੁਝ ਪ੍ਰਾਇਮਰੀ ਦਰਸ਼ਕਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, ਹਰ ਇੱਕ ਦੇ ਵੱਖਰੇ ਸੀਮਾਵਾਂ ਹੋਂਦੀਆਂ ਹਨ:
ਇਹ ਗਰੂਪ ਰੁਕਾਵਟਾਂ, ਬਦਲਦੇ ਯੋਜਨਾਵਾਂ ਦੀ ਆਵਿਰਤੀ, ਅਤੇ ਸਾਂਝੇ ਰਿਮਾਈਂਡਰ ਦੀ ਲੋੜ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਹੁੰਦੇ ਹਨ।
ਉਹ ਪਰਿਸਥਿਤੀਆਂ ਜਮ੍ਹਾਂ ਕਰੋ ਜੋ ਕਾਰਵਾਈਆਂ ਛੱਡਣ ਦਾ ਕਾਰਨ ਬਣਦੀਆਂ ਹਨ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਸੰਕੇਤਕ ਯੂਜ਼ ਕੇਸ ਬਣਾਓ:
ਇਹ ਲਿਖਦੇ ਸਮੇਂ, ਸੰਦਰਭ ਸ਼ਾਮਲ ਕਰੋ: ਸਮਾਂ ਵਿੰਡੋ, ਸਥਾਨ, ਆਮ ਡਿਵਾਈਸ ਹਾਲਤ (ਸਾਇਲੈਂਟ ਮੋਡ, ਘੱਟ ਬੈਟਰੀ), ਅਤੇ ਯੂਜ਼ਰ ਨੇ ਬਦਲ ਕੇ ਕੀ ਕੀਤਾ।
ਵਧੀਆ ਯੂਜ਼ਰ ਸਟੋਰੀਜ਼ ਤੁਹਾਡੇ ਨੋਟੀਫਿਕੇਸ਼ਨ ਡਿਜ਼ਾਈਨ ਫੈਸਲੇ ਸਪਸ਼ਟ ਕਰ ਦਿੰਦੀਆਂ ਹਨ:
ਐਪ ਦੇ ਲਕਸ਼ ਸਾਫ ਅਤੇ ਮਾਪਣ ਯੋਗ ਰੱਖੋ। ਜ਼ਿਆਦਾਤਰ ਰਿਮਾਈਂਡਰ ਐਪ ਚਾਰ ਮੁੱਖ ਕੰਮ ਨਿਭਾਉਂਦੇ ਹਨ:
ਡਿਫੌਲਟ ਨਤੀਜੇ ਤੇਜ਼ੇ ਨਾਲ ਰਿਜ਼ਲਟ ਬਣਾਉਂਦੇ ਹਨ। ਇੱਕ ਸਾਫ ਬੇਸਲਾਈਨ ਨਿਰਧਾਰਤ ਕਰੋ: ਸਮਝਦਾਰ ਸ਼ਾਂਤ ਘੰਟੇ, ਇੱਕ ਮਿਆਰੀ ਸਨੂਜ਼ ਅਵਧੀ, ਅਤੇ ਨਰਮ ਏਸਕਲੇਸ਼ਨ ਪੈਟਰਨ। ਲਕਸ਼ ਇਹ ਹੈ ਕਿ ਯੂਜ਼ਰ ਸਕਿੰਟਾਂ ਵਿੱਚ ਰਿਮਾਈਂਡਰ ਬਣਾਵੇ—ਅਤੇ ਫਿਰ ਵੀ ਐਪ ਨੂੰ ਬਿਨਾਂ ਬਹੁਤ ਟਿੂਨਿੰਗ ਦੇ "ਸਮਾਰਟ" ਮਹਿਸੂਸ ਕਰੇ।
ਰਿਮਾਈਂਡਰ ਐਪ ਉਸ ਬਰੋਟ 'ਤੇ ਟਿਕਿਆ ਹੋਇਆ ਹੁੰਦਾ ਹੈ ਕਿ ਉਪਭੋਗਤਾ ਕਿੰਨੀ ਤੇਜ਼ੀ ਨਾਲ ਇੱਕ ਇਰਾਦਾ ਕੈਪਚਰ ਕਰ ਸਕਦਾ ਹੈ ("ਮੈਨੂੰ ਯਾਦ ਦਿਵਾਉ") ਅਤੇ ਉਨ੍ਹਾਂ ਤੇ ਭਰੋਸਾ ਕਰ ਸਕਦੇ ਹਨ ਕਿ ਇਹ ਸਹੀ ਵੇਲੇ ਚਲੇਗਾ। "ਸਮਾਰਟ" ਲਾਜਿਕ ਜੋੜਨ ਤੋਂ ਪਹਿਲਾਂ, ਮੁੱਖ ਰਿਮਾਈਂਡਰ ਇਨਪੁੱਟ, ਸ਼ਡਿਊਲ ਨਿਯਮ, ਅਤੇ ਇੱਕ ਸਾਫ਼ ਡੇਟਾ ਮਾਡਲ ਨਿਰਧਾਰਤ ਕਰੋ ਜੋ ਤੁਹਾਨੂੰ ਬਾਅਦ ਵਿੱਚ ਫਸਾ ਨਾ ਕਰੇ।
ਅਸਲੀ ਰਵੈਯੇ ਨਾਲ میل ਖਾਣ ਵਾਲੇ ਕੁਝ ਬਣਾਉਣ ਦੇ ਰਾਹਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ:
ਅੱਚਾ ਨਿਯਮ: ਹਰ ਸਰੋਤ ਨੂੰ ਉ same ਹੀ ਅੰਦਰੂਨੀ ਰਿਮਾਈਂਡਰ ਓਬਜੈਕਟ ਉਤਪੰਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਵੱਖਰਾ ਪ੍ਰਕਾਰ ਨਹੀਂ।
ਰੀਕਰਿੰਗ ਰਿਮਾਈਂਡਰ ਅਕਸਰ ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਸਪੋਰਟ ਟਿਕਟ ਬਣਾਉਂਦੇ ਹਨ। ਨਿਯਮ ਸਪਸ਼ਟ ਰੱਖੋ:
ਇੱਕ ਸਾਫ ਮਾਡਲ ਚੁਣੋ ਅਤੇ ਉਸ ਤੇ ਟਿਕੇ ਰਹੋ:
ਗੈਰ-ਟੈਕਨੀਕਲ ਯੂਜ਼ਰਾਂ ਲਈ, ਇਸਨੂੰ "ਯਾਤਰਾ ਕਰਨ 'ਤੇ ਢਲ ਜਾਵੇ" ਬਨਾਮ "ਘਰੇਲੂ ਟਾਈਮਜ਼ੋਨ ਰੱਖੋ" ਦੇ ਰੂਪ ਵਿੱਚ ਲੇਬਲ ਕਰੋ।
ਲੋਕ ਲੋਕਾਂ ਨੂੰ ਰਾਹ ਵਿੱਚ ਰਿਮਾਈਂਡਰ ਬਣਾਉਣੇ ਪੈਂਦੇ ਹਨ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਯੂਜ਼ਰ ਆਫਲਾਈਨ ਰਿਚੀਏਟ/ਐਡੀਟ ਕਰ ਸਕਦੇ ਹਨ, ਬਦਲਾਵ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਸਟੋਰ ਹੋਣ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਸਿੰਕ ਹੋ ਜਾਣ। ਜੇ ਟਕਰਾਅ ਹੋਣ, ਤਾਂ "latest edit wins" ਨੂੰ ਤਰਜੀਹ ਦਿਓ ਅਤੇ ਸਧਾਰਨ ਐਕਟਿਵਿਟੀ ਲੌਗ ਰੱਖੋ।
ਇਸਨੂੰ ਪਤਲਾ ਰੱਖੋ ਪਰ ਸੰਰਚਿਤ:
ਇਹ ਬੁਨਿਆਦ ਪਰਸਨਲਾਈਜ਼ੇਸ਼ਨ ਬਾਅਦ ਵਿੱਚ ਆਸਾਨ ਬਣਾਂਦੀ ਹੈ—ਬਿਨਾਂ ਇਸਦੇ ਕਿ ਤੁਹਾਨੂੰ ਰਿਮਾਈਂਡਰ ਸਟੋਰ ਅਤੇ ਸ਼ਡਿਊਲ ਕਰਨ ਦਾ ਢਾਂਚਾ ਮੁੜ ਬਣਾਉਣਾ ਪਵੇ।
ਇੱਕ ਰਿਮਾਈਂਡਰ ਐਪ ਸੁਨੇਹੇ ਕਈ ਚੈਨਲਾਂ ਰਾਹੀਂ ਪਹੁੰਚਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਡੀ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਉਨ੍ਹਾਂ ਨੂੰ ਵੱਖਰੇ ਲਈ ਦਰਸ਼ਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਬਹੁਤ ਸਾਰੇ ਐਪ ਪਹਿਲਾਂ ਲੋਕਲ ਨੋਟੀਫਿਕੇਸ਼ਨ (ਡਿਵਾਈਸ 'ਤੇ ਸ਼ਡਿਊਲ ਕੀਤੇ) ਅਤੇ ਪੁਸ਼ ਨੋਟੀਫਿਕੇਸ਼ਨ (ਸਰਵਰ ਤੋਂ ਭੇਜੇ) ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ। ਈਮੇਲ/SMS "ਨਹਿ-ਮਿਸ" ਰਿਮਾਈਂਡਰ ਲਈ ਵਿਕਲਪ ਹੋ ਸਕਦੇ ਹਨ, ਪਰ ਉਹ ਵਾਧੂ ਲਾਗਤ, ਕਾਨੂੰਨੀ ਪਾਬੰਦੀਆਂ ਅਤੇ ਡਿਲਿਵਰੇਬਿਲਟੀ ਕੰਝਣੀਆਂ ਲਿਆਉਂਦੇ ਹਨ।
ਲੋਕਲ ਨੋਟੀਫਿਕੇਸ਼ਨ ਆਫਲਾਈਨ ਵਰਤੋਂ ਅਤੇ ਸਧਾਰਣ ਦੁਹਰਾਏ ਜਾਣ ਵਾਲੇ ਰਿਮਾਈਂਡਰ ਲਈ ਚੰਗੇ ਹਨ। ਇਹ ਤੇਜ਼ ਹਨ ਪਰ OS ਨਿਯਮਾਂ (ਬੈਟਰੀ ਓਪਟੀਮਾਈਜ਼ੇਸ਼ਨ, iOS 'ਤੇ ਨਿਯਮ) ਨਾਲ ਸੀਮਤ ਹੋ ਸਕਦੇ ਹਨ।
ਪੁਸ਼ ਨੋਟੀਫਿਕੇਸ਼ਨ ਕ੍ਰਾਸ-ਡਿਵਾਈਸ ਸਿੰਕ, "ਸਮਾਰਟ" ਟਾਈਮਿੰਗ, ਅਤੇ ਸਰਵਰ-ਚਲਿਤ ਅੱਪਡੇਟ (ਉਦਾਹਰਨ: ਜਦੋਂ ਕੰਮ ਹੋਰ ਥਾਂ 'ਤੇ ਮੁਕੰਮਲ ਹੋ ਜਾਏ ਤਾਂ ਰਿਮਾਈਂਡਰ ਰੱਦ ਕਰੋ) ਯੋਗ ਬਣਾਉਂਦੇ ਹਨ। ਇਹ APNs/FCM ਦੀ ਭਰੋਸੇਯੋਗਤਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ ਅਤੇ ਬੈਕਇੰਡ ਇੰਫ਼ਰਾਸਟਰੱਕਚਰ ਦੀ ਲੋੜ ਰੱਖਦੇ ਹਨ।
ਤੁਹਾਡੇ ਕੋਲ ਮੁੱਖ ਤੌਰ 'ਤੇ ਦੋ ਵਿਕਲਪ ਹਨ:
ਕਈ ਟੀਮਾਂ ਹਾਇਬਰਿਡ 'ਤੇ ਆਉਂਦੀਆਂ ਹਨ: ਡਿਵਾਈਸ-ਉਤੇ fallback (ਬੁਨਿਆਦੀ ਰਿਮਾਈਂਡਰ) + ਸਰਵਰ-ਸਾਈਡ ਅਪਟੀਮਾਈਜ਼ੇਸ਼ਨ (ਸਮਾਰਟ ਨੁਡਜ਼)।
ਘੱਟੋ-ਘੱਟ ਯੋਜਨਾ ਬਣਾਓ: authentication, ਇੱਕ ਡੇਟਾਬੇਸ ਰਿਮਾਈਂਡਰ/ਪਸੰਦਾਂ ਲਈ, ਟਾਈਮਡ ਕੰਮ ਲਈ ਜੌਬ ਸ਼ਡਿਊਲਰ/ਕਿਊ, ਅਤੇ ਡਿਲਿਵਰੀ/ਓਪਨ/ਕੰਪਲੀਸ਼ਨ ਈਵੈਂਟਸ ਲਈ ਅਨਲਿਟਿਕਸ।
ਜੇ ਤੁਸੀਂ ਤੁਰੰਤ ਪ੍ਰੋਟੋਟਾਈਪ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ Koder.ai ਵਰਗਾ ਚੈਟ-ਡ੍ਰਿਵਨ ਬਿਲਡ ਫਲੋ ਤੁਹਾਡੇ ਲਈ ਕੋਰ ਸਟੈਕ (React web surface, Go + PostgreSQL ਬੈਕਇੰਡ, Flutter ਮੋਬਾਈਲ) ਤੇਜ਼ੀ ਨਾਲ ਖੜਾ ਕਰਨ ਵਿੱਚ ਮਦਦਗਾਰ ਹੋ ਸਕਦਾ ਹੈ—ਫਿਰ ਨੋਟੀਫਿਕੇਸ਼ਨ ਲਾਜਿਕ 'ਤੇ ਸਿੱਖ ਕੇ ਇਟਰੇਟ ਕਰੋ।
ਮਾਰਨਿੰਗ ਰੁਟੀਨ, ਲੰਚ ਟਾਈਮ, ਸ਼ਾਮ ਦੇ ਅੰਤਰਾਲ ਵਗੈਰਾ 'ਤੇ ਟ੍ਰੈਫਿਕ spike ਦੀ ਉਮੀਦ ਰੱਖੋ। ਆਪਣੇ ਸ਼ਡਿਊਲਰ ਅਤੇ ਪੁਸ਼ ਪਾਈਪਲਾਈਨ ਨੂੰ ਬਰਸਟੀ ਸੈਂਡ, ਰੀਟ੍ਰਾਈ ਅਤੇ ਰੇਟ-ਲਿਮਿਟ ਹਨਡਲ ਕਰਨ ਲਈ ਡਿਜ਼ਾਈਨ ਕਰੋ।
ਕੈਲੰਡਰ ਸਿੰਕ, ਹੈਲਥ/ਐਕਟਿਵਿਟੀ ਸਿਗਨਲ, ਅਤੇ ਮੈਪਸ/ਲੋਕੇਸ਼ਨ ਟ੍ਰਿੱਗਰ ਲਈ ਐਕਸਟੈੰਸ਼ਨ ਪੋਇੰਟ ਰੱਖੋ—ਪਰ ਪਹਿਲੀ ਰਿਲੀਜ਼ ਲਈ ਇਹਨਾਂ ਨੂੰ ਲਾਜ਼ਮੀ ਨਾ ਬਣਾਓ।
ਰਿਮਾਈਂਡਰ ਐਪ ਦੀ ਕਾਇਮਾਤ opt-in 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ। ਜੇ ਤੁਸੀਂ ਬਹੁਤ ਜਲਦੀ ਪਰਮੀਸ਼ਨ ਮੰਗਦੇ ਹੋ, ਬਹੁਤ ਸਾਰੇ ਲੋਕ "Don’t Allow" ਦਬਾ ਦੇਣਗੇ ਅਤੇ ਫਿਰ ਮੁੜ ਨਹੀਂ ਆਉਣਗੇ। ਲਕਸ਼ ਸਧਾਰਨ ਹੈ: ਪਹਿਲਾਂ ਮੁੱਲ ਦਿਖਾਓ, ਫਿਰ ਛੋਟਾ ਤੇ ਲਾਜ਼ਮੀ ਪਰਮੀਸ਼ਨ ਮੰਗੋ ਜਦੋਂ ਉਸ ਦੀ ਸਪਸ਼ਟ ਲੋੜ ਹੋਵੇ।
ਛੋਟੀ ਆਨਬੋਰਡਿੰਗ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ ਜੋ ਨਤੀਜਿਆਂ ਨੂੰ ਦਿਖਾਉਂਦੀ ਹੈ, ਫੀਚਰ ਨਹੀਂ:
ਇੱਕ ਨੋਟੀਫਿਕੇਸ਼ਨ ਪ੍ਰੀਵਿਊ ਸਕਰੀਨ ਦਿਓ ਜੋ ਦਿਖਾਵੇ ਕਿ ਰਿਮਾਈਂਡਰ ਕਿਵੇਂ ਲੱਗੇਗਾ (title, body, timing, ਅਤੇ tapped ਤੇ ਕੀ ਹੁੰਦਾ)। ਇਹ ਅਚੰਭੇ ਨੂੰ ਘਟਾਉਂਦਾ ਅਤੇ ਭਰੋਸਾ ਵਧਾਉਂਦਾ ਹੈ।
ਨੋਟੀਫਿਕੇਸ਼ਨ ਪਰਮਿਸ਼ਨ ਸਿਰਫ ਉਸ ਵੇਲੇ ਮੰਗੋ ਜਦੋਂ ਯੂਜ਼ਰ ਪਹਿਲਾ ਰਿਮਾਈਂਡਰ ਬਣਾਉਂਦਾ ਹੈ (ਜਾਂ ਮੁੱਖ ਯੂਜ਼ ਕੇਸ ਚਾਲੂ ਕਰਦਾ ਹੈ)। ਰਿਕਵੈਸਟ ਨੂੰ ਕਿਸੇ ਕਾਰਵਾਈ ਨਾਲ ਜੋੜੋ:
ਪਹਿਲੀ ਮੰਗ ਨੂੰ ਕੰਮ ਅਤੇ ਸਿਰਫ਼ ਨੋਟੀਫਿਕੇਸ਼ਨ ਲਈ ਰੱਖੋ; ਜਦੋਂ ਲੋੜ ਹੋਵੇ ਵਧ ਦੇ ਹੱਕ ਮੰਗੋ (ਜਿਵੇਂ ਕੈਲੰਡਰ ਐਕਸੈਸ)। iOS ਅਤੇ Android 'ਤੇ ਇੱਕ-ਪਿੱਠੇ ਕਈ ਪਰਮੀਸ਼ਨ ਪ੍ਰੰਪਟ ਨਾ ਦਿਖਾਓ।
ਐਪ ਦੇ ਅੰਦਰ ਪਸੰਦਾਂ ਸਿੱਧੇ ਦਿਓ (ਸਿਸਟਮ ਸੈਟਿੰਗ ਵਿੱਚ ਛੁਪਾ ਕੇ ਨਹੀਂ):
ਇਹਨਾਂ ਨੂੰ ਰਿਮਾਈਂਡਰ ਬਣਾਉਣ ਦੀ ਸਕਰੀਨ ਅਤੇ ਇੱਕ ਸਪਸ਼ਟ Settings ਖੇਤਰ ਤੋਂ ਆਸਾਨੀ ਨਾਲ ਪਹੁੰਚਯੋਗ ਬਣਾਓ।
ਫੋਲਬੈਕ ਵਰਤੋਂ:
ਨੋਟੀਫਿਕੇਸ਼ਨ UX ਉਹ ਜਗ੍ਹਾ ਹੈ ਜਿੱਥੇ ਇੱਕ "ਸਮਾਰਟ" ਰਿਮਾਈਂਡਰ ਐਪ ਮਦਦਗਾਰ ਮਹਿਸੂਸ ਕਰਦਾ ਹੈ ਜਾਂ ਬੈਕਗਰਾਊਂਡ ਸ਼ੋਰ ਬਣ ਜਾਂਦਾ ਹੈ। ਵਧੀਆ UX ਆਮ ਤੌਰ 'ਤੇ ਤਿੰਨ ਚੀਜ਼ਾਂ ਬਾਰੇ ਹੈ: ਸਹੀ ਗੱਲ ਕਹਿਣਾ, ਸਹੀ ਗਤੀ ਅਤੇ ਯੂਜ਼ਰ ਨੂੰ ਸਹੀ ਸਕ੍ਰੀਨ 'ਤੇ ਲੈ ਕੇ ਜਾਣਾ।
ਉਹ ਕਿਸਮਾਂ ਦੇ ਨਾਮ ਰੱਖੋ ਜੋ ਤੁਹਾਡਾ ਐਪ ਭੇਜੇਗਾ। ਇੱਕ ਸਾਫ ਟੈਕਸੋਨੋਮੀ ਕਾਪੀ ਨੂੰ ਇੱਕਸਾਰ ਰੱਖਦੀ ਹੈ ਅਤੇ ਹਰ ਕਿਸਮ ਲਈ ਵੱਖ-ਵੱਖ ਨਿਯਮ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ:
ਸ਼ਾਨਦਾਰ ਨੋਟੀਫਿਕੇਸ਼ਨ ਕਾਪੀ ਕੀ, ਕਦੋਂ, ਅਤੇ ਅਗਲਾ ਕੀ ਕਰਨਾ ਹੈ ਦਾ ਜਵਾਬ ਦਿੰਦੀ ਹੈ—ਬਿਨਾਂ ਐਪ ਖੋਲ੍ਹੇ ਵਿਚਾਰ ਜ਼ਰੂਰਤ ਬਣਾਉਣ ਦੇ।
ਉਦਾਹਰਨ:
ਸਿਰਲੇਖ ਵਿਸ਼ੇਸ਼ ਰੱਖੋ, ਅਸਪਸ਼ਟ ਫਰੇਜ਼ਾਂ ਤੋਂ ਬਚੋ ("ਭੁੱਲੋ ਨਾ!"), ਅਤੇ ਕਾਰਵਾਈ ਬਟਨਾਂ ਨੂੰ ਸੰਭਾਲ ਕੇ ਅਤੇ ਨਿਯਮਤ ਤੌਰ 'ਤੇ ਵਰਤੋ (ਜਿਵੇਂ Snooze, Complete, Reschedule)।
ਇੱਕ ਸਮਾਰਟ ਰਿਮਾਈਂਡਰ ਐਪ ਸ਼ਾਂਤ ਮਹਿਸੂਸ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਰੋਜ਼ਾਨਾ cap ਪ੍ਰਤੀ ਨੋਟੀਫਿਕੇਸ਼ਨ ਕਿਸਮ ਅਤੇ ਘੱਟ-ਤਾਤਕਾਲਤਾ ਆਈਟਮਾਂ ਨੂੰ summaries ਵਿੱਚ ਬੈਚ ਕਰਨ ਵਰਗੀਆਂ ਨੀਤੀਆਂ ਰੱਖੋ।
ਨਾਲ ਹੀ "ਸਮਾਰਟ ਸਰੈਸਪਸ਼ਨ" ਨਿਯਮ ਜਿਵੇਂ:
ਹਰ ਨੋਟੀਫਿਕੇਸ਼ਨ ਯੂਜ਼ਰ ਨੂੰ ਸਿੱਧਾ ਸੰਬੰਧਿਤ ਟਾਸਕ 'ਤੇ ਖੋਲ੍ਹਣਾ ਚਾਹੀਦਾ ਹੈ, ਘਰ ਸਕ੍ਰੀਨ ਤੇ ਨਹੀਂ। ਡੀਪ ਲਿੰਕ ਉਦਾਹਰਨਾਂ:
ਇਸ ਨਾਲ ਰੁਕਾਵਟ ਘੱਟ ਹੁੰਦੀ ਹੈ ਅਤੇ ਮੁਕੰਮਲਤਾ ਵੱਧਦੀ ਹੈ।
ਪਾਠ ਪੜ੍ਹਨਯੋਗ ਰੱਖੋ (ਛੋਟੀ, ਭਾਰੀ ਲਿਖਤ ਤੋਂ ਬਚੋ), ਸਕ੍ਰੀਨ ਰੀਡਰਾਂ ਲਈ ਮੈਨੀੰਗਫੁਲ ਲੇਬਲ ਦਿਓ, ਅਤੇ ਨੋਟੀਫਿਕੇਸ਼ਨ ਕਾਰਵਾਈਆਂ ਲਈ ਟੈਪ ਟਾਰਗੇਟ ਵੱਡੇ ਰੱਖੋ। ਜੇ ਤੁਸੀਂ ਵਾਇਸ ਅਸਿਸਟੈਂਟ ਜਾਂ ਵੋਇਸ ਇਨਪੁਟ ਸਹਾਇਤਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਬੋਲਤਰਿਕ ਵਿਵਹਾਰ ਨਾਲ ਸ਼ਬਦਾਵਲੀ ਮੇਲ ਖਾਂਦੀ ਹੋਵੇ ("30 ਮਿੰਟ ਲਈ ਸਨੂਜ਼ ਕਰੋ").
"ਸਮਾਰਟ" ਦਾ ਮਤਲਬ ਜ਼ਰੂਰੀ ਨਹੀਂ ਕਿ ਜਟਿਲ AI ਹੋਵੇ। ਦੀਨ ਮਕਸਦ ਸਧਾਰਨ ਹੈ: ਸਹੀ ਰਿਮਾਈਂਡਰ, ਇਕ ਐਸੇ ਸਮੇਂ ਤੇ ਅਤੇ ਇਕ ਐਸੇ ਲਹਜੇ ਵਿੱਚ ਭੇਜੋ ਜੋ ਮੁਕੰਮਲਤਾ ਦੀ ਸੰਭਾਵਨਾ ਵੱਧਾਏ—ਬਿਨਾਂ ਪਰੇਸ਼ਾਨ ਕਰਨ ਦੇ।
Machine learning ਤੋਂ ਪਹਿਲਾਂ, ਸਾਫ ਨਿਯਮ ਅਤੇ ਹਲਕਾ ਸਕੋਰਿੰਗ ਮਾਡਲ ਲਗਾਓ। ਹਰ ਸੰਭਵ ਭੇਜਣ ਵੇਲੇ ਲਈ ਕੁਝ ਸਿਗਨਲਾਂ (ਜਿਵੇਂ, "ਯੂਜ਼ਰ ਆਮ ਤੌਰ 'ਤੇ 30 ਮਿੰਟ ਵਿੱਚ ਪੂਰਾ ਕਰਦਾ ਹੈ", "ਹੁਣ ਮੀਟਿੰਗ ਵਿੱਚ ਹੈ", "ਰਾਤ ਦੇ ਦੇਰ ਘੰਟੇ ਹਨ") ਤੋਂ ਸਕੋਰ ਗਣਨਾ ਕਰੋ। ਪਰਵੇਨਕ ਸਪਤ ਤੱਤੇ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵਧੀਆ ਸਕੋਰ ਵਾਲਾ ਸਮਾਂ ਚੁਣੋ।
ਇਹ ਢੰਗ ਬਲੈਕ-ਬੌਕਸ ਮਾਡਲ ਨਾਲੋਂ ਆਸਾਨ ਸਮਝਣਯੋਗ, ਡੀਬੱਗ ਅਤੇ ਸੁਧਾਰ ਯੋਗ ਹੁੰਦਾ ਹੈ—ਅਤੇ ਫਿਰ ਵੀ ਨਿੱਜੀ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ।
ਵਧੀਆ ਪर्सਨਲਾਈਜ਼ੇਸ਼ਨ ਆਮ ਤੌਰ 'ਤੇ ਉਹ ਪੈਟਰਨਾਂ ਤੋਂ ਆਉਂਦੀ ਹੈ ਜੋ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਟਰੈਕ ਕਰਦੇ ਹੋ:
ਸੰਦਰਭ ਉਹ ਸਮੇਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੁੰਦਾ ਹੈ ਜਦ ਇਹ ਸਪਸ਼ਟ ਅਤੇ ਆਦਰਸ਼ੀਕ ਹੋ:
ਸਮਾਰਟ ਸੈਂਡ ਵਿੰਡੋ ਲਾਗੂ ਕਰੋ: ਇਕ ਇਕਲ ਟਾਈਮਸਟੈਂਪ ਦੀ ਬਜਾਏ, ਯੂਜ਼ਰ-ਮਾਨਯਤਿਤ ਰੇਂਜ (ਉਦਾਹਰਨ: 9–11am) ਦੇ ਵਿੱਚ ਭੇਜੋ। ਇਸ ਨੂੰ do-not-disturb ਪੀਰੀਅਡ (ਜਿਵੇਂ 10pm–7am) ਨਾਲ ਜੋੜੋ ਅਤੇ ਪ੍ਰਤੀ ਰਿਮਾਈਂਡਰ overrides ਦੀ ਆਗਿਆ ਦਿਓ ਜੇ ਆਈਟਮ urgent ਹੈ।
ਯੂਜ਼ਰ ਨੂੰ ਦੱਸੋ ਕਿ ਰਿਮਾਈਂਡਰ ਕਿਉਂ moved ਹੋਇਆ: “ਅਸੀਂ ਇਹ 9:30am ਲਈ ਸ਼ਡਿਊਲ ਕੀਤਾ ਕਿਉਂਕਿ ਤੁਸੀਂ ਸਮਾਨ ਟਾਸਕ ਸਵੇਰੇ ਵਿੱਚ ਮੁਕੰਮਲ ਕਰਦੇ ਹੋ।” ਛੇਤੀ ਕੰਟਰੋਲ ਜਿਵੇਂ “ਮੂਲ ਸਮੇਂ 'ਤੇ ਭੇਜੋ” ਜਾਂ “ਹਮੇਸ਼ਾ 8am 'ਤੇ ਭੇਜੋ” ਸ਼ਾਮਲ ਕਰੋ। ਪर्सਨਲਾਈਜ਼ੇਸ਼ਨ ਇੱਕ ਮਦਦਗਾਰ ਸਹਾਇਕ ਵਾਂਗ ਮਹਿਸੂਸ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਗੁਪਤ ਸੈਟਿੰਗ ਵਾਂਗ ਨਹੀਂ।
ਜਦੋਂ ਯੂਜ਼ਰ ਬਹੁਤ ਵਿਆਸਤ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਐਪ ਉਸ ਵੇਲੇ effortless ਹੋਵੇ ਤਾਂ ਇਹ "ਸਮਾਰਟ" ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਪੂਰੇ ਲਾਈਫਸਾਈਕਲ ਦਾ ਡਿਜ਼ਾਈਨ: create → alert → act → schedule ਨੂੰ ਅਪਡੇਟ ਕਰੋ → ਲੂਪ ਬੰਨ ਕਰੋ।
ਬਣਾਉਣ ਹਲਕਾ ਰੱਖੋ: ਸਿਰਲੇਖ, ਸਮਾਂ, ਅਤੇ (ਵਿਕਲਪਿਕ) ਰੀਪੀਟ ਨਿਯਮ। ਹੋਰ ਸਭ—ਨੋਟ, ਸਥਾਨ, ਪ੍ਰਾਇਰਟੀ—ਜੋੜਨਯੋਗ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ, ਲਾਜ਼ਮੀ ਨਹੀਂ।
ਜੇ ਤੁਸੀਂ ਰੀਕਰਿੰਗ ਸਹਾਇਤਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਨਿਯਮ ਨੂੰ ਹਰੇਕ ਘਟਨਾ ਤੋਂ ਅਲੱਗ ਸਟੋਰ ਕਰੋ। ਇਸ ਨਾਲ "ਅਗਲੀ ਘਟਨਾ" ਦਿਖਾਉਣਾ ਅਤੇ ਸ਼ਡਿਊਲ ਦੀਆਂ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣਾ ਆਸਾਨ ਹੁੰਦਾ ਹੈ।
ਨੋਟੀਫਿਕੇਸ਼ਨਾਂ ਨੂੰ quick actions ਸਹਾਇਤਾ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਤਾਂ ਕਿ ਯੂਜ਼ਰ ਐਪ ਖੋਲ੍ਹਣ ਤੋਂ ਬਿਨਾਂ ਮੁਕੰਮਲ ਕਰ ਸਕੇ:
ਜਦੋਂ ਇੱਕ quick action ਸ਼ਡਿਊਲ ਬਦਲਦਾ ਹੈ, UI ਨੂੰ ਤੁਰੰਤ ਅਪਡੇਟ ਕਰੋ ਅਤੇ ਰਿਮਾਈਂਡਰ ਇਤਿਹਾਸ ਵਿੱਚ ਲੌਗ ਰੱਖੋ ਤਾਂ ਕਿ ਬਾਅਦ ਵਿੱਚ ਯੂਜ਼ਰ ਵੇਖ ਸਕੇ ਕਿ ਕੀ ਹੋਇਆ।
ਸਨੂਜ਼ ਜ਼ਿਆਦਾਤਰ ਸਮੇਂ ਇੱਕ ਟੈਪ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਕਈ ਪ੍ਰੀਸੈੱਟ ਦਿਓ (ਉਦਾਹਰਨ: 5 ਮਿੰਟ, 15 ਮਿੰਟ, 1 ਘੰਟਾ, ਸਵੇਰੇ ਕੱਲ੍ਹ) ਅਤੇ ਕਸਟਮ ਟਾਈਮ ਪਿਕਰ ਵੀ।
ਰੀ-ਸ਼ੈਡਿਊਲ ਸਨੂਜ਼ ਤੋਂ ਵੱਖਰਾ ਹੈ: ਇਹ ਇਕ ਇਰਾਦਾਪੂਰਕ ਬਦਲਾਅ ਹੈ। ਇਕ ਸਧਾਰਨ ਪਿਕਰ ਅਤੇ ਸਮਾਰਟ ਸੁਝਾਅ (ਅਗਲਾ ਖਾਲੀ ਸਮਾਂ, ਆਮ ਪੂਰਾ ਕਰਨ ਦਾ ਸਮਾਂ, "ਮੇਰੀ ਮੀਟਿੰਗ ਤੋਂ ਬਾਅਦ") ਦਿਓ। ਬਿਨਾਂ ਜਟਿਲ ਪर्सਨਲਾਈਜ਼ੇਸ਼ਨ ਦੇ ਵੀ, "ਅੱਜ ਬਾਅਦ" ਅਤੇ "ਕੱਲ੍ਹ" ਸ਼ਾਰਟਕਟ ਤਕਲੀਫ ਘਟਾਉਂਦੇ ਹਨ।
ਜਦੋਂ ਯੂਜ਼ਰ ਰਿਮਾਈਂਡਰ ਖੋਲ੍ਹਦਾ ਹੈ, ਦਿਖਾਓ:
ਇਹ ਡੀਟੇਲ ਪੇਜ ਗਲਤੀਆਂ undo ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਜਗ੍ਹਾ ਹੈ।
ਪੁਸ਼ ਅਤੇ ਲੋਕਲ ਨੋਟੀਫਿਕੇਸ਼ਨ dismiss ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਇਕ ਇਨ-ਐਪ Notification Center ਜੋ ਮਿਸਡ ਰਿਮਾਈਂਡਰਾਂ ਨੂੰ ਹੱਲ ਹੋਣ ਤੱਕ ਰੱਖੇ, ਜੋੜੋ। ਹਰ ਆਈਟਮ ਤੇ ਉਹੇ ਕਾਰਵਾਈਆਂ ਮਿਲਣ: done, snooze, reschedule।
ਅਸਲੀ ਜ਼ਿੰਦਗੀ ਲਈ ਡਿਜ਼ਾਈਨ ਕਰੋ:
ਇਹ ਫੈਸਲੇ ਗੁਲਾਬੀਪਣ ਘਟਾਉਂਦੇ ਹਨ ਅਤੇ ਐਪ ਨੂੰ ਭਰੋਸੇਯੋਗ ਬਣਾਉਂਦੇ ਹਨ।
ਸਮਾਰਟ ਰਿਮਾਈਂਡਰ "ਰੱਖਉ" ਨਹੀਂ ਹਨ। ਸਭ ਤੋਂ ਤੇਜ਼ ਤਰੀਕਾ ਰਿਲੈਵੈਂਸੀ ਬਹਿਤਰ ਕਰਨ ਦਾ ਉਹ ਹੈ ਕਿ ਨੋਟੀਫਿਕੇਸ਼ਨ ਨੂੰ ਉਤਪਾਦ ਸਰਫੇਸ ਵਜੋਂ ਮਾਪੋ, ਟੈਸਟ ਕਰੋ ਅਤੇ ਸੁਧਾਰੋ।
ਰਿਮਾਈਂਡਰ ਲਾਈਫਸਾਈਕਲ ਨਾਲ ਮੈਪ ਹੋਣ ਵਾਲੇ ਈਵੈਂਟਸ ਲੌਗ ਕਰਨ ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ। iOS ਅਤੇ Android 'ਤੇ ਨਾਮ ਇਕਸਾਰ ਰੱਖੋ ਤਾਂ ਤੁਸੀਂ ਵਿਵਰਤੀਆਂ ਦੀ ਤੁਲਨਾ ਕਰ ਸਕੋ।
ਘੱਟੋ-ਘੱਟ ਟਰੈਕ ਕਰੋ:
ਸੰਦਭ ਪ੍ਰਾਪਰਟੀਆਂ ਸ਼ਾਮਲ ਕਰੋ ਜੋ ਸਮਝਾਉਂਦੀਆਂ ਹਨ ਕਿਉਂ ਕੁਝ ਹੋਇਆ: reminder type, scheduled time, user timezone, channel (local vs push), ਅਤੇ ਕੀ ਇਹ personalization rule ਵੱਲੋਂ trigger ਹੋਇਆ।
ਡੈਸ਼ਬੋਰਡ ਤੁਹਾਨੂੰ ਅਗਲਾ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ, ਸਿਰਫ vanity metrics ਰਿਪੋਰਟ ਕਰਨ ਲਈ ਨਹੀਂ। ਉਪਯੋਗੀ ਦ੍ਰਿਸ਼:
ਜੇ ਤੁਸੀਂ ਡੀਪ ਲਿੰਕ ਸਮਰਥਨ ਕਰਦੇ ਹੋ, ਤਾਂ "open to intended screen" ਦਰ ਮਾਪੋ ਤਾਂ ਜੋ ਟੁੱਟੀ ਰੂਟਿੰਗ ਪਤਾ ਲੱਗੇ।
A/B ਟੈਸਟਿੰਗ ਸਮੇਂ-ਵਿੰਡੋ ਅਤੇ ਕਾਪੀ ਬਦਲਾਅ ਲਈ ਆਦਰਸ਼ ਹੈ, ਪਰ ਆਦਰਸ਼ ਨਾਲ। ਯੂਜ਼ਰ ਪਸੰਦਾਂ (quiet hours, frequency caps, categories) ਹਮੇਸ਼ਾਂ ਉੱਚਤਰ ਤਰਜੀਹ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ।
ਟੈਸਟ ਵਿਚਾਰ:
ਜਦੋਂ ਯੂਜ਼ਰ ਬਾਰ-ਬਾਰ ਸਨੂਜ਼ ਜਾਂ ਰੀ-ਸ਼ੈਡਿਊਲ ਕਰਦਾ ਹੈ, ਇਹ ਇਕ ਸਿਗਨਲ ਹੈ। ਇਕ ਨਿਰਧਾਰਤ ਪੈਟਰਨ (ਉਦਾਹਰਨ: ਹਫਤੇ ਵਿੱਚ ਤਿੰਨ ਸਨੂਜ਼) ਤੋਂ ਬਾਅਦ, ਇਕ ਛੋਟਾ ਪ੍ਰਸ਼ਨ ਪੁੱਛੋ: “ਕੀ ਇਹ ਮਦਦਗਾਰ ਸੀ?” ਅਤੇ ਇਕ-ਟੈਪ ਸੁਧਾਰ ਦਿਓ ਜਿਵੇਂ "ਟਾਈਮ ਬਦਲੋ" ਜਾਂ "ਰਿਮਾਈਂਡਰ ਘਟਾਓ"।
ਕੋਹੋਰਟ ਵਿਸ਼ਲੇਸ਼ਣ ਨਾਲ ਦੇਖੋ ਕਿ ਕੀ ਚੀਜ਼ ਯੂਜ਼ਰਾਂ ਨੂੰ ਜ਼ਿੰਦਾ ਰੱਖਦੀ ਹੈ: ਰਿਮਾਈਂਡਰ ਕਿਸਮ, opt-in ਸਮਾਂ, ਜਾਂ ਪਹਿਲੇ ਹਫ਼ਤੇ ਦੀ completion rate। ਨਤੀਜੇ ਨੂੰ ਨਿਯਮਤ ਕੈਡੈਂਸ 'ਤੇ ਰਿਵਿਊ ਕਰੋ, ਛੋਟੇ-ਛੋਟੇ ਬਦਲਾਅ ਸ਼ਿਪ ਕਰੋ, ਅਤੇ ਜੋ ਸਿੱਖਿਆ ਉਸਨੂੰ ਦਸਤਾਵੇਜ਼ ਕਰੋ ਤਾਂ ਕਿ ਪרסਨਲਾਈਜ਼ੇਸ਼ਨ ਨਿਯਮ ਸਬੂਤ ਦੇ ਆਧਾਰ 'ਤੇ ਵਿਕਸਤ ਹੋਣ।
ਸਮਾਰਟ ਨੋਟੀਫਿਕੇਸ਼ਨ ਨਿੱਜੀ ਮਹਿਸੂਸ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਗੋਪਨੀਯਤਾ ਅਤੇ ਸੁਰੱਖਿਆ ਗੈਰ-ਚਰਚਾ ਯੋਗ ਹਨ। ਸਭ ਤੋਂ ਸਧਾਰਨ ਤਰੀਕਾ ਜੋ ਖਤਰੇ ਘਟਾਉਂਦਾ ਹੈ ਉਹ ਇਹ ਹੈ ਕਿ ਤੁਹਾਡੀ ਰਿਮਾਈਂਡਰ ਐਪ ਘੱਟੋਂ-ਘੱਟ ਨਿੱਜੀ ਡੇਟਾ ਨਾਲ ਮੁੱਲ ਪਹੁੰਚਾ ਸਕੇ—ਅਤੇ ਜੋ ਕੁਝ ਵੀ ਤੁਸੀਂ ਇਕੱਠਾ ਕਰਦੇ ਹੋ ਉਸ ਬਾਰੇ ਪਾਰਦਰਸ਼ੀ ਹੋਵੋ।
"ਨੋ-ਨੋ-ਨੋ" ਮਨੋਵਿਰਤੀ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ। ਜੇ ਰਿਮਾਈਂਡਰ ਬਿਨਾਂ ਲੋਕੇਸ਼ਨ, ਕੰਟੈਕਟ ਜਾਂ ਕੈਲੰਡਰ ਐਕਸੈਸ ਦੇ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ, ਤਾਂ ਮੰਗੋ ਹੀ ਨਾ। ਜੇ ਸੰਵੇਦਨਸ਼ੀਲ ਇਨਪੁਟ ਦੀ ਲੋੜ ਹੈ (ਜਿਵੇਂ ਲੋਕੇਸ਼ਨ-ਅਧਾਰਤ ਰਿਮਾਈਂਡਰ), ਤਾਂ ਉਹ ਵਿਕਲਪਿਕ ਰੱਖੋ ਅਤੇ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਉਸ ਫੀਚਰ ਨਾਲ ਜੋੜੋ ਜੋ ਯੂਜ਼ਰ ਨੇ ਖੋਲ੍ਹਿਆ।
ਇੱਕ عملي ਨਿਯਮ: ਜੇ ਤੁਸੀਂ ਇਕ ਫੀਲਡ ਸਟੋਰ ਕਰਨ ਦਾ ਕਾਰਨ ਇੱਕ ਵਾਕ ਵਿੱਚ ਨਹੀਂ ਦੱਸ ਸਕਦੇ, ਤਾਂ ਉਸਨੂੰ ਹਟਾ ਦੇਵੋ।
ਡੇਟਾ ਉਪਯੋਗ ਦੋ ਥਾਵਾਂ 'ਤੇ ਸਮਝਾਓ:
ਅਸਪਸ਼ਟ ਭਾਸ਼ਾ ਤੋਂ ਬਚੋ। ਦੱਸੋ ਕਿ ਤੁਸੀਂ ਕੀ ਇਕੱਤਰ ਕਰਦੇ ਹੋ, ਕਿਉਂ, ਅਤੇ ਕਿੰਨੀ ਦੇਰ ਲਈ ਰੱਖਦੇ ਹੋ।
ਪੁਸ਼ ਨੋਟੀਫਿਕੇਸ਼ਨ ਲਈ ਡਿਵਾਈਸ ਟੋਕਨ (APNs on iOS, FCM on Android) ਲੋੜੀਂਦੇ ਹਨ। ਟੋਕਨਾਂ ਨੂੰ ਸੰਵੇਦਨਸ਼ੀਲ ਤੱਤ ਸਮਝੋ:
ਦਿਨ ਪਹਿਲਾਂ ਹੀ ਯੂਜ਼ਰ-ਚਲਾਉ ਉਤਪਾਦ ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ: ਖਾਤਾ ਮਿਟਾਉਣ 'ਤੇ ਨਿੱਜੀ ਡੇਟਾ ਹਟਾ ਦਿਓ ਅਤੇ ਪੁਸ਼ ਟੋਕਨਾਂ ਨੂੰ ਅਮਾਨਤ ਕਰੋ।
iOS/Android ਨੀਤੀਆਂ ਅਤੇ ਸਹਿਮਤੀ ਦੀਆਂ ਲੋੜਾਂ ਦਾ ਸਤਿਕਾਰ ਕਰੋ: ਕੋਈ ਲੁਕਾਇਆ ਟ੍ਰੈਕਿੰਗ ਨਹੀਂ, opt-in ਬਿਨਾਂ ਪੁਸ਼ ਨਾ ਭੇਜੋ, ਅਤੇ ਗੁਮਰਾਹ ਕਰਨ ਵਾਲੀ ਸਮੱਗਰੀ ਨਾ ਭੇਜੋ।
ਯੂਜ਼ਰ ਕੰਟਰੋਲ ਜੋ ਭਰੋਸਾ ਬਣਾਉਂਦੇ ਹਨ:
ਇਹ ਬੁਨਿਆਦੀ ਗੱਲਾਂ ਬਾਅਦ ਵਿੱਚ ਅਨੁਕੂਲਤਾ ਨੂੰ ਆਸਾਨ ਬਣਾਉਂਦੀਆਂ ਹਨ ਅਤੇ “ਸਮਾਰਟ” ਫੀਚਰਾਂ ਨੂੰ ਯੂਜ਼ਰ ਅਸਹਜਤਾ ਵਿੱਚ ਨਹੀਂ ਬਦਲਣ ਦਿੰਦੀਆਂ।
ਨੋਟੀਫਿਕੇਸ਼ਨ ਉਹ ਫੀਚਰ ਹਨ ਜੋ ਡੈਮੋ ਵਿੱਚ ਠੀਕ ਲੱਗ ਸਕਦੇ ਹਨ ਪਰ ਅਸਲ ਜ਼ਿੰਦਗੀ ਵਿੱਚ ਫੇਲ ਹੋ ਸਕਦੇ ਹਨ। ਟੈਸਟਿੰਗ ਅਤੇ ਲਾਂਚ ਤਿਆਰੀ ਨੂੰ ਉਤਪਾਦ ਦਾ ਹਿੱਸਾ ਸਮਝੋ, ਨਾ ਕਿ ਆਖਰੀ ਰੁਕਾਵਟ।
ਕਈ OS ਵਰਜ਼ਨਾਂ ਅਤੇ ਨਿਰਮਾਤਿਆਂ (ਮੁੱਖ ਤੌਰ 'ਤੇ Android) 'ਤੇ ਡਿਲਿਵਰੀ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ। ਵੱਖ-ਵੱਖ ਡਿਵਾਈਸ ਹਾਲਤਾਂ ਨਾਲ ਏਕ ਰਿਮਾਈਂਡਰ ਐਂ-ਟੂ-ਐਂਡ ਟੈਸਟ ਕਰੋ:
ਟਾਈਮਿੰਗ ਬੱਗ ਭਰੋਸਾ ਖੋਣ ਦਾ ਸਭ ਤੋਂ ਤੇਜ਼ ਤਰੀਕਾ ਹਨ। ਖਾਸ QA ਸ਼ਾਮਲ ਕਰੋ:
ਜੇ ਤੁਸੀਂ ਰੀਕਰਿੰਗ ਸਹਾਇਤਾ ਕਰਦੇ ਹੋ, ਤਾਂ "ਮਹੀਨੇ ਦਾ ਆਖਰਾ ਦਿਨ", ਲੀਪ-ਈਅਰ, ਅਤੇ "ਸਿਰਫ਼ ਕਾਰਜ ਦਿਨ" ਲਾਜਿਕ ਟੈਸਟ ਕਰੋ।
ਰਿਲੀਜ਼ ਤੋਂ ਪਹਿਲਾਂ, ਆਪਣੀ ਟੀਮ ਲਈ ਇੱਕ ਆਸਾਨ ਚੈੱਕਲਿਸਟ ਤਿਆਰ ਕਰੋ ਜੋ ਦੁਹਰਾਈ ਜਾ ਸਕੇ:
ਜੇ ਤੁਸੀਂ ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ ਜਾਂ ਲਗਾਤਾਰ ਇਟਰੇਸ਼ਨ ਲਈ ਸਹਾਇਤਾ ਦੀ ਯੋਜਨਾ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਉਮੀਦਾਂ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਪੰਨਿਆਂ ਜਿਵੇਂ /pricing ਉੱਤੇ ਸੰਗਠਿਤ ਕਰੋ।
ਪੋਸਟ-ਲਾਂਚ, ਉਹ ਅੱਪਗਰੇਡਾਂ 'ਤੇ ਧਿਆਨ ਦਿਓ ਜੋ ਸ਼ੋਰ ਘਟਾਉਂਦੀਆਂ ਅਤੇ ਉਪਯੋਗੀਤਾ ਵਧਾਉਂਦੀਆਂ ਹਨ:
ਜੇ ਤੁਹਾਡੀ ਟੀਮ v1 ਤੋਂ ਬਾਅਦ ਤੇਜ਼ ਇਟਰੇਸ਼ਨ ਰੱਖਣਾ ਚਾਹੁੰਦੀ ਹੈ, ਤਾਂ Koder.ai ਵਰਗੇ ਟੂਲਸ ਤੁਹਾਨੂੰ ਬਦਲਾਅ ਛੋਟੇ ਲੂਪਾਂ ਵਿੱਚ ship ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੇ ਹਨ (UI, ਬੈਕਐਂਡ, ਮੋਬਾਈਲ) ਅਤੇ ਇੱਕਸਾਰ ਸਰੋਤ ਕੋਡ ਨਿਰੀਆਤ ਕਰਨ ਅਤੇ ਕਸਟਮ ਡੋਮੇਨ ਨਾਲ ਡਿਪਲੌਇ ਕਰਨ ਦੀ ਆਸਾਨੀ ਦਿੰਦੇ ਹਨ—ਜਦੋਂ ਨੋਟੀਫਿਕੇਸ਼ਨ ਅਤੇ ਸ਼ਡਿਊਲ ਲਾਜਿਕ ਤੇਜ਼ੀ ਨਾਲ ਵਿਕਸਤ ਹੋ ਰਹੀ ਹੋ।
For deeper guidance on content, frequency, and deep links, see /blog/notification-ux-best-practices.