08 ਜੁਲਾ 2025·8 ਮਿੰਟ
ਕਿਵੇਂ ਬਿਨਾਂ ਓਵਰਲੋਡ ਦੇ ਮੋਬਾਈਲ ਐਪ ਵਿੱਚ ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਬਣਾਉਣੇ
ਇਸ ਲੇਖ ਵਿੱਚ ਸਿੱਖੋ ਕਿ ਕਿਵੇਂ ਇੱਕ ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਐਪ ਬਣਾਈਏ ਜੋ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਸਹੀ ਵਕਤ 'ਤੇ ਮਦਦ ਕਰੇ ਬਿਨਾਂ ਨੋਟੀਫਿਕੇਸ਼ਨ ਥਕਾਵਟ ਤੋਂ—ਸਿਗਨਲ, UX ਪੈਟਰਨ, ਗੋਪਨੀਯਤਾ ਅਤੇ ਟੈਸਟਿੰਗ।
ਇਸ ਲੇਖ ਵਿੱਚ ਸਿੱਖੋ ਕਿ ਕਿਵੇਂ ਇੱਕ ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਐਪ ਬਣਾਈਏ ਜੋ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਸਹੀ ਵਕਤ 'ਤੇ ਮਦਦ ਕਰੇ ਬਿਨਾਂ ਨੋਟੀਫਿਕੇਸ਼ਨ ਥਕਾਵਟ ਤੋਂ—ਸਿਗਨਲ, UX ਪੈਟਰਨ, ਗੋਪਨੀਯਤਾ ਅਤੇ ਟੈਸਟਿੰਗ।
ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਡਿਜ਼ਾਇਨ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਉਪਭੋਗਤਾ ਨਤੀਜੇ ਨੂੰ ਸਧੀ ਭਾਸ਼ਾ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ: ਸਹੀ ਯਾਦ ਦਿਵਾਣਾ, ਸਹੀ ਸਮੇਂ, ਘੱਟ ਤੋਂ ਘੱਟ ਦਖਲਅੰਦਾਜ਼ੀਆਂ ਨਾਲ। ਜੇ ਇਹ ਵਾਕਅਨਕ ਜੀਵਨ ਵਿੱਚ ਸੱਚ ਨਹੀਂ ਹੈ, ਤਾਂ “ਸਮਾਰਟ ਨੋਟੀਫਿਕੇਸ਼ਨ” ਤੁਰੰਤ ਨੋਟੀਫਿਕੇਸ਼ਨ ਥਕਾਵਟ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹਨ।
ਇੱਕ ਲਾਭਦਾਇਕ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਸ਼ਨ ਇਹ ਹੈ: "ਉਪਭੋਗਤਾ ਨੇ ਕੀ ਭੁੱਲਿਆ, ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਯਾਦ ਰੱਖਣ ਵਿੱਚ ਕੀ ਮੱਦਦ ਕਰਦੀ ਜਿਸ ਨਾਲ ਉਹਨਾਂ ਦੀ ਧਿਆਨਭੰਗ ਨਾ ਹੋਵੇ?" ਇਹ ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰਾਂ ਨੂੰ ਅਸਲੀ ਪਲਾਂ ਵਿੱਚ ਰੱਖਦਾ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ ਚਤੁਰ ਆਟੋਮੇਸ਼ਨ ਵਿੱਚ।
ਮੋਬਾਈਲ ਐਪ ਡਿਜ਼ਾਇਨ ਵਿੱਚ, “ਸੰਦਰਭ” ਉਹ ਸਿਗਨਲ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਚੁਣਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ ਕਿ ਕਦੋਂ ਅਤੇ ਕਿਵੇਂ ਯਾਦ ਦਿਵਾਉਣਾ ਹੈ। ਆਮ ਸੰਦਰਭ ਸਿਗਨਲ ਸ਼ਾਮਿਲ ਹਨ:
ਤੁਸੀਂ ਕਿਹੜੇ ਸਿਗਨਲ ਸਪੋਰਟ ਕਰਦੇ ਹੋ ਅਤੇ ਕਿਉਂ, ਇਹ ਸਪਸ਼ਟ ਦੱਸੋ। ਇੱਕ ਰਿਮਾਈਂਡਰ ਐਪ UX ਕੇਵਲ ਸਮਾਂ + ਕੈਲੰਡਰ + ਡਿਵਾਈਸ ਹਾਲਤ ਤੋਂ ਵੀ “ਸੰਦਰਭਿਕ” ਹੋ ਸਕਦਾ ਹੈ—ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਸਭ ਕੁਝ ਸ਼ਾਮਿਲ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ।
“ਮਦਦਗਾਰ, ਨਾ ਕਿ ਸ਼ੋਰ” ਨੂੰ ਦਰਸਾਉਣ ਵਾਲੀਆਂ ਕੁਝ ਮੈਟਰਿਕ ਚੁਣੋ:
ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰਾਂ ਨੂੰ ਸੀਮਾਵਾਂ ਨੇ ਆਕਾਰ ਦਿੰਦੇ ਹਨ: OS ਨੋਟੀਫਿਕੇਸ਼ਨ ਹੱਦਾਂ, ਬੈਕਗ੍ਰਾਊਂਡ ਐਕਜ਼ੀਕਿਊਸ਼ਨ ਨਿਯਮ, ਬੈਟਰੀ ਪ੍ਰਭਾਵ ਅਤੇ ਪਰਮਿਸ਼ਨ। ਆਪਣੇ ਗੋਪਨੀਯਤਾ-ਦਿਆਨ ਰਵੱਈਏ ਨੂੰ ਪਹਿਲਾਂ ਸਪਸ਼ਟ ਕਰੋ: ਲੋੜੀਂਦੇ ਨਿਊਨਂਤਮ ਸਿਗਨਲ ਹੀ ਇਕੱਤਰ ਕਰੋ, ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਜ਼ਿਆਦਾਤਰ ਪ੍ਰੋਸੈਸਿੰਗ ਡਿਵਾਈਸ 'ਤੇ ਕਰੋ, ਅਤੇ “ਹੈਰਾਨ ਕਰਨ ਵਾਲੀ” ਨਿੱਜੀਕਰਨ ਤੋਂ ਬਚੋ ਜਿਸਨੂੰ ਉਪਭੋਗਤਾ ਸਮਝ ਨਾ ਸਕੇ।
ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਤਦ ਹੀ “ਸਮਾਰਟ” ਮਹਿਸੂਸ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਉਹ ਅਸਲੀ ਜੀਵਨ ਨਾਲ ਮਿਲਦੇ ਹਨ। ਆਪਣੀ ਖੋਜ ਦੀ ਸ਼ੁਰੂਆਤ ਪਲਾਂ (ਜਦੋਂ ਰਿਮਾਈਂਡਰ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ), ਜਾਬਸ (ਲੋਕ ਕੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਨ), ਅਤੇ ਫੇਲਿਆ ਮੋਡ (ਰਿਮਾਈਂਡਰ ਕਿਵੇਂ ਗਲਤ ਹੋ ਜਾਂਦੇ ਹਨ) 'ਤੇ ਕੇਂਦਰਤ ਕਰਕੇ ਕਰੋ।
ਛੋਟਾ ਸਮੂਹ ਚੁਣੋ ਜਿਸ ਲਈ ਤੁਸੀਂ ਐਂਡ-ਟੂ-ਐਂਡ ਡਿਜ਼ਾਇਨ ਕਰ ਸਕੋ:
ਹਰ ਇੱਕ ਪੇਰਸੋਨਾ ਦਾ ਦੈਨੀਕ ਰਿਥਮ, ਸੀਮਾਵਾਂ (ਹੱਥ-ਰਹਿਤ, ਚੁਪ ਘੰਟੇ, ਸਾਂਝੇ ਡਿਵਾਈਸ) ਅਤੇ “ਸਫਲਤਾ” ਦਾ ਕੀ ਮਤਲਬ ਹੈ (ਘੱਟ ਤਣਾਅ, ਘੱਟ ਛੁੱਟੇ ਕੰਮ, ਵਧੀਕ ਪੂਰਨਤਾ) ਲਿਖੋ।
ਦੋਹਰਾਏ ਜਾ ਸਕਣ ਵਾਲੇ, ਉੱਚ-ਮੁੱਲ ਵਾਲੇ ਕੰਮਾਂ ਲਈ ਪ੍ਰਯਾਸ ਕਰੋ, ਜਿਵੇਂ:
ਜਾਬਸ ਨੂੰ ਸਧੀ ਭਾਸ਼ਾ ਵਿੱਚ ਫਰਮਾਇਸ਼ ਕਰੋ: “ਜਦੋਂ Y ਹੋਵੇ ਤਾਂ ਮੈਨੂੰ X ਯਾਦ ਦਿਵਾਓ,” ਫੀਚਰ ਦੀ ਬੇਨਤੀ ਨਹੀਂ।
ਉਹ ਚੰਦ ਪਲਾਂ ਪਛਾਣੋ ਜਿੱਥੇ ਟਾਈਮਿੰਗ ਜਰੂਰੀ ਹੈ:
ਫੋਨ ਕਿੱਥੇ ਹੋ ਸਕਦਾ ਹੈ (ਜੀਬ, ਬੈਗ, ਮਾਊਂਟ), ਅਤੇ ਕੀ ਸਾਉਂਡ/ਵਾਈਬਰੇਸ਼ਨ ਮਨਜ਼ੂਰਯੋਗ ਹੈ, ਇਹ ਕੈਪਚਰ ਕਰੋ।
ਉਹ ਦਸਤਾਵੇਜ਼ ਕਰੋ ਜੋ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਬੁਰਾ ਲੱਗਦਾ ਹੈ, ਫਿਰ ਗਾਰਡਰੇਲ ਬਣਾਓ:
ਇਹ ਫੇਲਿਅਰ ਤੁਹਾਡੇ ਪ੍ਰਾਇਓਰਿਟਾਈਜ਼ੇਸ਼ਨ ਨਿਯਮਾਂ, ਚੁਪ ਘੰਟਿਆਂ ਅਤੇ ਨੋਟੀਫਿਕੇਸ਼ਨ ਕਾਪੀ ਨੂੰ ਸਿੱਧਾ ਪ੍ਰਭਾਵਿਤ ਕਰਨਗੇ।
ਸੰਦਰਭ ਇੱਕ ਰਿਮਾਈਂਡਰ ਨੂੰ ਬੇਹਦ ਸੁਯੋਜਤ ਮਹਿਸੂਸ ਕਰਵਾ ਸਕਦਾ ਹੈ—ਜਾਂ ਅਸਵਾਵਿਕ “ਟਰੇਕ” ਵਾਲਾ। ਇੱਕ ਚੰਗਾ ਨਿਯਮ ਇਹ ਹੈ ਕਿ ਉਹ ਸਿਗਨਲ ਸ਼ੁਰੂ ਕਰੋ ਜੋ ਉੱਚ-ਮੁੱਲ ਅਤੇ ਘੱਟ-ਘੇਰਾਵਾਲੇ ਹਨ, ਫਿਰ ਸਿਰਫ਼ ਉਦੋਂ ਵਧਾਓ ਜਦੋਂ ਯੂਜ਼ਰ ਨੂੰ ਸਪਸ਼ਟ ਲਾਭ ਦਿੱਸੇ।
ਬਹੁਤ ਸਾਰਥਕ ਕ੍ਰਮ ਬਹੁਤ ਸਾਰੀਆਂ ਰਿਮਾਈਂਡਰ ਐਪਾਂ ਲਈ ਇਹ ਹੈ:
ਜੇਕਰ ਕੋਈ ਸਿਗਨਲ ਟਾਈਮਿੰਗ ਨੂੰ ਗੋਰਾ ਜਾਂ ਕਮ ਨਹੀਂ ਕਰਦੀ, ਤਾਂ ਉਸਦੀ ਆਗਿਆ ਮੰਗਣ ਦਾ ਖ਼ਰਚ ਨਹੀਂ ਕਮਾਉ।
ਇੱਕ “ਬਿਨਾ-ਪਰਮਿਸ਼ਨ” ਬੇਸਲਾਈਨ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਫਿਰ ਵੀ ਚੰਗਾ ਕੰਮ ਕਰੇ (ਆਮ ਤੌਰ 'ਤੇ ਸਮਾਂ-ਅਧਾਰਿਤ ਰਿਮਾਈਂਡਰ). ਰਿਚਰ ਸੰਦਰਭ ਨੂੰ opt-in ਅੱਪਗਰੇਡ ਵਜੋਂ ਰੱਖੋ:
ਸਿਗਨਲ ਫੇਲ ਹੁੰਦੇ ਹਨ: GPS ਬੰਦ, ਕੈਲੰਡਰ ਕੁਨੈਕਟ ਨਹੀਂ, ਬੈਕਗ੍ਰਾਊਂਡ ਰਿਸਟ੍ਰਿਕਸ਼ਨ। ਹਰ ਰਿਮਾਈਂਡਰ ਲਈ ਇੱਕ ਫਾਲਬੈਕ ਹੋਣਾ ਚਾਹੀਦਾ:
ਸ਼ੁਰੂ ਤੋਂ ਹੀ ਹੱਦਾਂ ਲਿਖੋ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਇੱਕਸਾਰ ਰੱਖੋ: ਮਾਈਕ੍ਰੋਫੋਨ ਆਕਸੇਸ ਨਹੀਂ, ਲਗਾਤਾਰ ਟ੍ਰੈਕਿੰਗ ਨਹੀਂ, ਕੱਚੇ ਸੰਦਰਭ ਡੇਟਾ ਦਾ ਵਿਕਰੇਣ ਜਾਂ ਸਾਂਝਾ ਨਹੀਂ। ਇਹ ਫੈਸਲੇ ਉਤਪਾਦ ਸਕੋਪ ਸਾਦਾ ਕਰਦੇ ਹਨ ਅਤੇ ਭਰੋਸਾ ਆਸਾਨੀ ਨਾਲ ਕਮਾਉਂਦੇ ਹਨ।
ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਤਦ ਹੀ “ਸਮਾਰਟ” ਮਹਿਸੂਸ ਹੋਂਦੇ ਹਨ ਜਦੋਂ ਉਹ ਸੁਰੱਖਿਅਤ ਵੀ ਮਹਿਸੂਸ ਹੋਣ। ਲੋਕ ਇੱਕ ਛੁੱਟੀ ਹੋਈ ਯਾਦ ਮੰਨ ਲੈਣਗੇ; ਪਰ ਉਹ ਉਸ ਯਾਦ ਨੂੰ ਮੰਨਣਗੇ ਨਹੀਂ ਜੇ ਉਹ ਸੋਚਦੇ ਹਨ ਕਿ ਤੁਸੀਂ ਬਿਨਾਂ ਆਗਿਆ ਟ੍ਰੈਕ ਕਰ ਰਹੇ ਹੋ।
ਪ੍ਰਮਿਸ਼ਨ ਪ੍ਰਾਂਪਟ vague ਜਾਂ ਡਰਾਉਣ ਵਾਲੇ ਨਹੀਂ ਹੋਣੇ ਚਾਹੀਦੇ। ਸਪਸ਼ਟ ਹੋਵੋ ਕਿ ਤੁਸੀਂ ਕੀ ਚਾਹੁੰਦੇ ਹੋ, ਕਿਉਂ ਚਾਹੁੰਦੇ ਹੋ, ਅਤੇ ਹੁਣੇ ਉਪਭੋਗਤਾ ਨੂੰ ਕੀ ਲਾਭ ਮਿਲੇਗਾ।
ਉਦਾਹਰਣ:
ਜੇ ਤੁਸੀਂ ਬਿਨਾਂ ਆਗਿਆ ਦੇ ਮੁੱਲ ਦੇ ਸਕਦੇ ਹੋ, ਪਹਿਲਾਂ ਉਹ ਦਿਓ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਪੁੱਛੋ—ਜਦੋਂ ਯੂਜ਼ਰ ਫੀਚਰ ਨੂੰ ਸਮਝ ਲਵੇ।
ਡਿਫਾਲਟ ਤੌਰ 'ਤੇ ਨਿਊਨੱਤਮ ਡੇਟਾ ਇਕੱਤਰਣ ਨੂੰ ਲਗਾਓ। ਜੇ ਕੋਈ ਰਿਮਾਈਂਡਰ ਡਿਵਾਈਸ 'ਤੇ ਟ੍ਰਿਗਰ ਹੋ ਸਕਦਾ ਹੈ (ਸਮਾਂ ਵਿੰਡੋ, ਜਿਓਫੇੰਸ, ਮੋਸ਼ਨ ਸਟੇਟ), ਤਾਂ ਕੱਚਾ ਸੰਦਰਭ ਡੇਟਾ ਸਰਵਰ ਤੇ ਭੇਜਣ ਦੀ ਬਜਾਏ ਉਹਨੂੰ ਅੱਪਰੇਂਡ ਕਰੋ।
ਵਿਹਾਰਕ ਗਾਰਡਰੇਲ:
ਜਦੋਂ ਉਪਭੋਗਤਾ ਆਪਣੀ ਰਾਈ ਪਲਟਣਾ ਚਾਹੁੰਦੇ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਖੋਜਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ। ਤੇਜ਼ ਨਿਯੰਤਰਣ ਸ਼ਾਮਿਲ ਕਰੋ:
ਇਨ-ਐਪ ਗੋਪਨੀਯਤਾ ਵਿਵਰਣ ਇੱਕ ਸਹਾਇਤਾ ਆਰਟਿਕਲ ਵਾਂਗ ਲਿਖੋ: ਤੁਹਾਨੂੰ ਕੀ ਸਟੋਰ ਕਰਦੇ ਹੋ, ਕੀ ਨਹੀਂ, ਕਿੰਨੇ ਸਮੇਂ ਲਈ ਰੱਖਦੇ ਹੋ, ਅਤੇ ਕਿਵੇਂ ਬੰਦ ਕਰਨਾ ਹੈ। ਪਾਰਦਰਸ਼ੀ ਐਪ ਜ਼ਿਆਦਾ ਆਗਿਆ ਮਿਲਦੇ ਹਨ—ਅਤੇ ਘੱਟ ਅਨਇੰਸਟਾਲ।
ਇੱਕ ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਵੱਧਤਰ ਤਰੀਕੇ ਨਾਲ “ਸਮਾਰਟ” ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਮਾਡਲ ਸਪਸ਼ਟ ਹੁੰਦਾ ਹੈ। UI ਤੋਂ ਪਹਿਲਾਂ, ਇੱਕ ਰਿਮਾਈਂਡਰ ਨੂੰ ਛੋਟੇ ਬਿਲਡਿੰਗ ਬਲਾਕਸ ਦੇ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਕਨਸਿਸਟੈਂਟ ਤਰੀਕੇ ਨਾਲ ਮੁੱਲਿਆੰਕਣ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।
ਘੱਟੋ-ਘੱਟ, ਹਰ ਰਿਮਾਈਂਡਰ ਨੂੰ ਮਾਡਲ ਕਰੋ:
ਇੱਕ ਸਧਾ ਪ੍ਰਤੀਨਿਧਿਤ ਰੂਪ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਲੱਗ ਸਕਦਾ ਹੈ:
{
"trigger": "arrive:home",
"conditions": ["weekday", "not_completed"],
"message": "Ask Alex about the keys",
"action": "open:reminder_detail",
"priority": "normal",
"expiry": "2026-01-10T20:00:00Z",
"no_repeat": true
}
(ਇਹ ਕੋਡ ਫੈਂਸਡ ਬਲਾਕ ਅਣਬਦਲ ਰੱਖਿਆ ਗਿਆ ਹੈ।)
ਉਪਭੋਗਤਾਵਾਂ ਜੋ ਤੁਰੰਤ ਸਮਝ ਆ ਜਾਂਦੇ ਹਨ, ਉਨ੍ਹਾਂ ਲਈ ਫਿਰ-ਵਰਤੋਂਯੋਗ ਟੈਮਪਲੇਟ ਸਪੋਰਟ ਕਰੋ, ਜਿਵੇਂ “ਜਦੋਂ ਮੈਂ ਇੱਥੇ ਪਹੁੰਚਾਂ…”, “ਜਦੋਂ ਮੈਂ ਛੱਡਾਂ…”, “ਕਿਸੇ ਸਮੇਂ…”, ਅਤੇ “ਕਾਲ ਮਗਰੋਂ…”। ਟੈਮਪਲੇਟਸ ਨੂੰ ਉਹੀ ਅਧਾਰਭੂਤ ਖੇਤਰਾਂ ਨਾਲ ਸਾਫ਼ ਮਿਲਾਉਣਾ ਚਾਹੀਦਾ ਹੈ ਤਾਂ ਜੋ ਸੰਪਾਦਨ ਪੈਟਰਨ ਤੇ ਅਟੱਲ ਰਹੇ।
ਹਰ ਰਿਮਾਈਂਡਰ ਨੂੰ ਮਿਆਦ ਦੇਣਾ ਡਿਫਾਲਟ ਕਰੋ (ਭਲੇ ਹੀ ਮੁਹੱਈਆ ਮਿਆਦ ਹੋਵੇ)। no-repeat (ਇੱਕ ਵਾਰੀ ਚੱਲੇ) ਅਤੇ ਕੂਲਡਾਊਨਸ (X ਘੰਟਿਆਂ ਲਈ ਮੁੜ ਨਾ ਚਲੇ) ਜੋੜੋ ਤਾਂ ਕਿ ਸਿਸਟਮ ਜ਼ਹਿਰ ਨਾ ਕਰੇ।
ਰਿਮਾਈਂਡਰ ਫਾਇਰ ਹੋਣ ਤੋਂ ਬਾਅਦ ਫਾਸਟ ਕਨਟਰੋਲ ਦਿਓ: Done, Snooze, Mute this context, Edit, Delete। ਇਹ ਥਾਂ ਉਹ ਹੈ ਜਿੱਥੇ ਉਪਭੋਗਤਾ ਤੁਹਾਡੇ ਮਾਡਲ ਨੂੰ ਸਿਖਾਉਂਦਾ ਹੈ ਕਿ “ਮਦਦਗਾਰ” ਕੀ ਹੈ।
ਇੱਕ ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਪ੍ਰਣਾਲੀ ਫੇਲ ਹੋ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਇਹ “ਸਪ੍ਰੇ” ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦੀ ਹੈ। ਤੁਹਾਡੀ ਡਿਫਾਲਟ ਰਾਹਤ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ: ਘੱਟ, ਉੱਚ-ਭਰੋਸੇ ਵਾਲੇ ਰਿਮਾਈਂਡਰ ਬਹੁਤ ਸਾਰੇ ਘੱਟ-ਭਰੋਸੇ ਵਾਲੇ ਅਨੁਮਾਨਾਂ ਨਾਲੋਂ ਬਿਹਤਰ ਹਨ। ਹਰ ਪੁਸ਼ ਨੂੰ ਇੱਕ ਕੀਮਤੀ ਸਰੋਤ ਸਮਝੋ।
ਸਪਸ਼ਟ ਉਪਭੋਗਤਾ ਮੁੱਲ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਛੋਟੇ ਪ੍ਰਾਇਓਰਿਟੀ ਟੀਅਰ ਬਣਾਓ। ਉਦਾਹਰਣ:
ਸਿਰਫ਼ ਉੱਚ ਟੀਅਰ ਲਈ ਹੀ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਡਿਸਰਪਟਿਵ ਅਲਰਟ ਯੋਗ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। ਬਾਕੀ ਨੂੰ ਮਜ਼ਬੂਤ ਸੰਦਰਭ ਸਿਗਨਲ ਤੋਂ ਬਾਅਦ ਹੀ ਦਖਲ ਦੇਣ ਦੀ ਆਗਿਆ ਮਿਲੇ।
“ਨੋਟੀਫਾਈ ਜਾਂ ਨਹੀਂ” ਫੈਸਲੇ ਦੀ ਥਾਂ, ਇੱਕ ਪ੍ਰਗਰੈਸ਼ਨ ਵਰਤੋ:
ਇਸ ਨਾਲ ਤੁਸੀਂ ਸੁਚੱਜੇ ਰੂਪ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੇ ਹੋ ਬਿਨਾਂ ਸ਼ੋਰ ਬਣਾਉਣ ਦੇ।
ਹਰੇਕ ਸ਼੍ਰੇਣੀ ਅਤੇ ਕੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਫ੍ਰੀਕੈਂਸੀ ਕੈਪ ਲਾਗੂ ਕਰੋ। ਫਿਰ ਕੀਜੋ ਕੂਲਡਾਊਨ ਵਿੰਡੋਜ਼ ਮੁੱਖ ਇੰਟਰਐਕਸ਼ਨਾਂ ਤੋਂ ਬਾਅਦ—ਜੇ ਯੂਜ਼ਰ ਨੇ ਸਨੂਜ਼ ਕੀਤਾ, ਪੂਰਾ ਕੀਤਾ ਜਾਂ ਡਿਸਮਿਸ ਕੀਤਾ, ਤਾਂ ਤੁਰੰਤ ਮੁੜ-ਪਿੰਗ ਨਾ ਕਰੋ। ਡਿਸਮਿਸ ਤੋਂ ਬਾਅਦ ਕੂਲਡਾਊਨ ਪੂਰਾ ਕਰਨ ਦੇ ਮੁਕਾਬਲੇ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਅਦ ਛੋਟੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।
ਜਦੋਂ ਕਈ ਰਿਮਾਈਂਡਰ ਇਕੱਠੇ ਹੁੰਦੇ ਹਨ (ਉਹੇ ਸਥਾਨ, ਉਹੀ ਸਮਾਂ ਵਿੰਡੋ, ਉਹੀ ਪ੍ਰਾਜੈਕਟ), ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਨੋਟੀਫਿਕੇਸ਼ਨ ਵਿੱਚ ਬੰਡਲ ਕਰੋ ਜਿਸ ਵਿੱਚ ਛੋਟਾ ਸੰਖੇਪ ਹੋਵੇ। ਟੈਪ 'ਤੇ ਇੱਕ ਸਾਫ਼ ਲਿਸਟ ਖੁੱਲ੍ਹੇ ਤਾਂ ਜੋ ਯੂਜ਼ਰ ਇੱਕ ਵਾਰੀ ਵਿੱਚ ਕਾਰਵਾਈ ਕਰ ਸਕਣ, ਗੁਣਮਾਨਾ ਵੱਖ-ਵੱਖ ਵਿਛੋੜੇ ਰੁਕਾਵਟਾਂ ਦੀ ਬਜਾਏ।
ਇੱਕ ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਨੋਟੀਫਿਕੇਸ਼ਨ ਖੁਦ ਨੁਕਸਾਨ ਜਾਂ ਫਾਇਦਾ ਦਾ ਫੈਸਲਾ ਕਰਦੀ ਹੈ: ਸ਼ਬਦਬੰਦੀ, ਟਾਈਮਿੰਗ ਸੰਕੇਤ, ਅਤੇ ਇੱਕ ਟੈਪ ਵਿੱਚ ਕੀ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਨੋਟੀਫਿਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਛੋਟੀ ਫੈਸਲਾ ਸਕਰੀਨ ਵਜੋਂ ਸਲਾਹ ਦਿਓ, ਨਾ ਕਿ ਇੱਕ ਛੋਟਾ ਲੇਖ।
ਸੁਨੇਹਾ ਸੰਖਿਪਤ ਅਤੇ ਸਕੈਨਏਬਲ ਰੱਖੋ:
ਉਦਾਹਰਣ ਢਾਂਚਾ: “ਦਵਾਈ ਲੈਓ — ਤੁਸੀਂ City Pharmacy ਦੇ ਨੇੜੇ ਹੋ — ਖੋਲੋ ਲਿਸਟ।” ਜੇ “ਹੁਣ ਕਿਉਂ” ਬਹੁਤ creepਯ ਮਹਿਸੂਸ ਹੋ ਸਕਦਾ ਹੈ (ਠੀਕ ਸਥਾਨ), ਤਾਂ ਇਸਨੂੰ ਨਰਮ ਕਰੋ: “ਤੁਸੀਂ ਨੇੜੇ ਹੋ” ਜਾਂ “ਨਿਕਲ ਰਹੇ ਹੋ।”
1–3 ਕਾਰਵਾਈਆਂ ਜ਼ਿਆਦਾ ਤੋਂ ਜ਼ਿਆਦਾ ਰੱਖੋ:
ਨੋਟੀਫਿਕੇਸ਼ਨ ਵਿੱਚ “Edit,” “Share,” ਜਾਂ “Reschedule” ਵਰਗੇ ਵਿਰੋਧੀ ਬਟਨਾਂ ਤੋਂ ਬਚੋ—ਉਹ ਐਪ ਵਿੱਚ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।
ਸਨੂਜ਼ ਪ੍ਰੀਸੈੱਟਸ਼ वास्तविक ਪਰਿਸਥਿਤੀਆਂ ਨਾਲ ਮੇਲ ਖਾਣੇ ਚਾਹੀਦੇ ਹਨ:
ਜੇ ਤੁਸੀਂ ਕਿਸੇ ਪ੍ਰੀਸੈਟ ਨੂੰ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਸਮਰਥਨ ਨਹੀਂ ਕਰ ਸਕਦੇ (ਜਿਵੇਂ “ਅਗਲਾ ਸਥਾਨ”), ਤਾਂ ਉਹ ਨਾ ਦਿਖਾਓ।
ਦੋਸ਼, ਜ਼ਰੂਰਤ ਜਾਂ ਦਬਾਅ ਛੱਡੋ (“ਭੁੱਲ ਨਾ ਜਾਓ!”, “ਤੁਹਾਨੂੰ ਕਰਨਾ ਹੀ ਹੈ…”). ਸ਼ਾਂਤ ਭਾਸ਼ਾ ਵਰਤੋ: “ਰਿਮਾਈਂਡਰ: ਪੌਦਿਆਂ ਨੂੰ ਪਾਣੀ ਦਿਓ” ਅਤੇ “Snoozed until 7pm.” ਇਕ ਆਦਰਸ਼ ਟੋਨ ਤਣਾਅ ਘੱਟ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਨੋਟੀਫਿਕੇਸ਼ਨ ਚਾਲੂ ਰੱਖਣ ਲਈ ਉਤਸ਼ਾਹਿਤ ਕਰਦਾ ਹੈ।
ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਤਦ ਹੀ “ਸਮਾਰਟ” ਮਹਿਸੂਸ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਉਪਭੋਗਤਾ ਆਪਣੇ ਉੱਤੇ ਕਬਜ਼ਾ ਮਹਿਸੂਸ ਕਰਦੇ ਹਨ। ਭਰੋਸਾ ਬਣਾਉਣ ਦਾ ਸਭ ਤੋਂ ਤੇਜ਼ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਹਰ ਰਿਮਾਈਂਡਰ ਨੂੰ ਸਮਝਣਯੋਗ ਅਤੇ ਇੱਕ-ਦੋ ਟੈਪ ਵਿੱਚ ਸੋਧਯੋਗ ਬਣਾਇਆ ਜਾਵੇ—ਬਿਨਾ ਲੋਕਾਂ ਨੂੰ ਸੈਟਿੰਗਾਂ ਦੀ ਖੋਜ 'ਤੇ ਭੇਜੇ।
ਨੋਟੀਫਿਕੇਸ਼ਨ ਆਸਾਨੀ ਨਾਲ ਗੁਮ ਹੋ ਸਕਦੇ ਹਨ, ਖਾਸ ਕਰਕੇ ਮੀਟਿੰਗਾਂ ਜਾਂ ਚੁਪ ਘੰਟਿਆਂ ਦੌਰਾਨ। ਇੱਕ ਇਨ-ਐਪ ਰਿਮਾਈਂਡਰ ਇਨਬਾਕਸ ਲੋਕਾਂ ਨੂੰ ਆਪਣੀ ਰਫ਼ਤਾਰ 'ਤੇ ਕੈਚ-ਅੱਪ ਕਰਨ ਦਿੰਦਾ ਹੈ ਬਿਨਾ ਵਾਧੂ ਪਿੰਗਾਂ ਦੇ।
ਇਹ ਸਧਾਰਾ ਰੱਖੋ: ਕ੍ਰੋਨੋਲੋਜਿਕਲ ਲਿਸਟ ਸਾਫ਼ ਲੇਬਲਾਂ ("Due now", "Later today"), ਹਲਕੀ ਕਾਰਵਾਈਆਂ (Done, Snooze), ਅਤੇ ਸਰੋਚ ਜਾਂ ਫਿਲਟਰ ਕਰਨ ਦਾ ਰਾਹ। ਇਹ ਤਤਕਾਲ ਕਾਰਵਾਈ ਕਰਨ ਦੀ ਦਬਾਅ ਘਟਾਉਂਦਾ ਹੈ ਅਤੇ ਨੋਟੀਫਿਕੇਸ਼ਨ ਥਕਾਵਟ ਘਟਾਉਂਦਾ ਹੈ।
ਹਰ ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਵਿੱਚ ਇੱਕ ਛੋਟਾ ਵਿਵਰਨ ਪੈਨਲ ਹੋਣਾ ਚਾਹੀਦਾ:
ਸਧੀ ਭਾਸ਼ਾ ਵਿੱਚ ਲਿਖੋ: “ਤੁਸੀਂ Home ਦੇ ਨੇੜੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ Laundry ਲਈ ਇੱਥੇ ਆਉਣ 'ਤੇ ਯਾਦ ਕਰਵਾਉਣ ਲਈ ਕਿਹਾ ਸੀ।” ਤਕਨੀਕੀ ਸ਼ਬਦ ਜਿਵੇਂ “geofence triggered” ਤੋਂ ਬਚੋ।
ਜਦੋਂ ਰਿਮਾਈਂਡਰ ਗਲਤ ਮਹਿਸੂਸ ਹੋਵੇ, ਉਪਭੋਗਤਾ ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਖੋਜ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ। ਇਕ-ਟੈਪ ਨਿਯੰਤਰਣ ਸਮੇਤ:
ਸਧੀ ਭਾਸ਼ਾ ਵਰਤੋ ("Quiet hours", "Places", "How often") ਨਾਂ ਕਿ ਘਨੇ ਟੌਗਲ। ਇਨਬਾਕਸ ਅਤੇ “ਕਿਉਂ ਇਹ” ਵਿਊ ਤੋਂ ਇਹ ਨਿਯੰਤਰਣ ਸਪੱਸ਼ਟ ਕਰੋ ਤਾਂ ਉਪਭੋਗਤਾ ਇਸਨੂੰ ਠੀਕ ਓਹਲੇ 'ਤੇ ਲਭ ਸਕਣ।
ਇੱਕ ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਸਿਰਫ਼ ਸਹੀ ਸਮੇਂ 'ਤੇ ਫਾਇਰ ਹੋਵੇ, ਬਿਨਾ ਫੋਨ ਨੂੰ ਖਾਂਦੇ—ਇਹੀ “ਸਮਾਰਟ” ਹੋਣ ਦੀ ਨਿਗਰਾਨੀ ਹੈ। ਮਕਸਦ ਇਹ ਹੈ ਕਿ OS ਦੇ ਸ਼ੈਡੀਊਲਿੰਗ ਟੂਲਾਂ 'ਤੇ ਨਿਰਭਰ ਰਹੋ, ਨਾ ਕਿ ਆਪਣਾ ਲਗਾਤਾਰ ਬੈਕਗ੍ਰਾਊਂਡ ਚਲਾਓ।
ਲੋਕਲ-ਪਹਿਲਾ ਨਾਲ ਸਿੰਕ ਆਮ ਤੌਰ 'ਤੇ ਰਿਮਾਈਂਡਰਾਂ ਲਈ ਸਭ ਤੋਂ ਸੁਰੱਖਿਅਤ ਡਿਫਾਲਟ ਹੈ। ਨਿਯਮ ਡਿਵਾਈਸ 'ਤੇ ਮੁੱਲਿਆੰਕਿਤ ਹੁੰਦੇ ਹਨ, ਇਸ ਲਈ ਟ੍ਰਿਗਰ ਆਫਲਾਈਨ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਡਿਵਾਈਸ ਸੈਟਿੰਗਾਂ (Focus/DND) ਦਾ ਆਦਰ ਕਰ ਸਕਦੇ ਹਨ।
ਸਰਵਰ-ਚਲਾਊ ਨਿਯਮ ਉਨ੍ਹਾਂ ਹਾਲਤਾਂ 'ਚ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ ਜਦੋਂ ਸੰਦਰਭ ਸਿਗਨਲ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸਰਵਰ-ਸਾਈਡ ਉੱਪਲਬਧ ਹਨ (ਉਦਾਹਰਣ ਲਈ, ਤੁਹਾਡਾ ਕੈਲੰਡਰ), ਪਰ ਅਜੇ ਵੀ ਨੋਟੀਫਿਕੇਸ਼ਨ ਨੂੰ ਭਰੋਸੇਯੋਗ ਢੰਗ ਨਾਲ ਸ਼ੈਡਿਊਲ ਕਰਨ ਲਈ ਡਿਵਾਈਸ-ਸਾਈਡ ਲੇਅਰ ਦੀ ਲੋੜ ਪਵੇਗੀ।
ਇੱਕ ਕਾਰਗਰ ਹਾਈਬ੍ਰਿਡ ਇਹ ਹੈ: ਨਿਯਮ ਕਲਾਉਡ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਡਿਵਾਈਸਾਂ ਵਿੱਚ ਸਥਿਰਤਾ ਲਈ), ਪਰ ਉਨ੍ਹਾਂ ਨੂੰ ਡਿਵਾਈਸ-ਅਨੁਕੂਲ ਸ਼ੈਡਿਊਲਾਂ ਵਿੱਚ ਕੰਪਾਇਲ ਕਰੋ।
ਜੇ ਤੁਸੀਂ ਇਸ ਕਿਸਮ ਦਾ ਹਾਈਬ੍ਰਿਡ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰੋਟੋਟਾਈਪ ਕਰ ਰਹੇ ਹੋ, ਇੱਕ vibe-coding ਵਰਕਫਲੋ (ਉਦਾਹਰਣ ਦੇ ਤੌਰ 'ਤੇ Koder.ai ਵਰਤ ਕੇ React-ਆਧਾਰਿਤ ਐਡਮਿਨ ਕੰਸੋਲ ਅਤੇ Go/PostgreSQL ਬੈਕਏਂਡ ਬਣਾਉਣਾ) ਇਟਰੇਸ਼ਨ ਚੱਕਰ ਤੇਜ਼ ਕਰ ਸਕਦਾ ਹੈ—ਖਾਸ ਕਰਕੇ ਨਿਯਮ ਮਾਡਲਿੰਗ, ਇਵੈਂਟ ਲੋਗਿੰਗ, ਅਤੇ ਇੱਕ ਅੰਦਰੂਨੀ “ਕਿਉਂ ਇਹ ਚਲਿਆ” ਡੀਬੱਗ ਵਿਊ ਲਈ।
ਮੋਬਾਈਲ ਪਲੇਟਫਾਰਮ ਬੈਕਗ੍ਰਾਊਂਡ ਐਕਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਕਮ ਦੇ ਰਹੇ ਹਨ:
ਟ੍ਰਿਗਰਜ਼ ਨੂੰ OS ਪ੍ਰਿਮਿਵਜ਼ (scheduled notifications, geofence entry/exit, significant location change, system task schedulers) ਦੇ ਆਧਾਰ 'ਤੇ ਡਿਜ਼ਾਇਨ ਕਰੋ।
ਪੋਲਿੰਗ ਤੋਂ ਬਚੋ। ਇਸ ਦੀ ਥਾਂ:
ਰਿਮਾਈਂਡਰ ਨਿਰਭਰਯੋਗ ਬਣਾਓ ਬਿਨਾ ਸਪੈਮ ਕੀਤੇ:
ਹਰ ਟ੍ਰਿਗਰ ਨੂੰ "ਸਰਵੋਤਮ ਕੋਸ਼ਿਸ਼" ਵਜੋਂ ਸਮਝੋ, ਅਤੇ ਸੰਰਕਸ਼ਾਵਾਂ ਬਣਾਓ ਤਾਂ ਕਿ "ਦਿੱਲੇ" ਆਉਣਾ "ਅਗਲਾ ਸਭ ਤੋਂ ਚੰਗਾ ਸਮਾਂ" ਬਣ ਜਾਏ—"ਕਈ ਪਿੰਗ" ਨਹੀਂ।
ਇੱਕ ਰਿਮਾਈਂਡਰ ਐਪ ਉਹ ਧਿਆਨ ਕਮਾਉਂਦਾ ਹੈ ਜੋ ਉਹ ਮੰਗਦਾ ਹੈ ਇਸ ਤੋਂ ਪਹਿਲਾਂ। onboarding ਨੂੰ ਇੱਕ ਛੋਟਾ “ਲਾਭ ਦਾ ਸਬੂਤ” ਫਲੋ ਬਣਾਓ, ਨਾ ਕਿ ਪਰਮਿਸ਼ਨ ਚੈਕਲਿਸਟ।
ਸਧਾਰਾ, ਸਮਾਂ-ਅਧਾਰਿਤ ਰਿਮਾਈਂਡਰ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ ਜੋ ਕਿਸੇ ਵਿਸ਼ੇਸ਼ ਐਕਸੈਸ ਦੀ ਲੋੜ ਨਹੀਂ ਰੱਖਦਾ। ਯੂਜ਼ਰ ਨੂੰ ਇੱਕ ਮਿੰਟ ਤੋਂ ਘੱਟ ਵਿੱਚ ਇੱਕ ਰਿਮਾਈਂਡਰ ਬਣਾਉਣ ਦੀ ਆਗਿਆ ਦਿਓ ਅਤੇ ਇਸ ਲਾਭ (ਚੰਗੀ-ਟਾਈਮਡ ਨੋਟੀਫਿਕੇਸ਼ਨ) ਦਾ ਅਨੁਭਵ ਕਰਨ ਦਿਓ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਨੋਟੀਫਿਕੇਸ਼ਨ ਆਗਿਆ ਮੰਗਦੇ ਹੋ।
ਜਦੋਂ ਤੁਸੀਂ ਪੁڇੋ, ਸਪਸ਼ਟ ਹੋਵੋ: “ਨੋਟੀਫਿਕੇਸ਼ਨ ਦੀ ਆਗਿਆ ਦਿਓ ਤਾਂ ਕਿ ਅਸੀਂ ਤੁਹਾਨੂੰ 6:00 PM 'ਤੇ ਯਾਦ ਦਿਵਾ ਸਕੀਏ।” ਇਹ ਮਕਸਦੀ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ, ਨਾ ਕਿ ਧੱਕਾ ਦੇਣ ਵਾਲਾ।
ਸੰਦਰਭ ਸਿਗਨਲਾਂ ਨੂੰ ਧੀਰੇ-ਧੀਰੇ ਪੇਸ਼ ਕਰੋ:
ਜੇ ਕਿਸੇ ਫੀਚਰ ਨੂੰ ਬੈਕਗ੍ਰਾਊਂਡ ਸਥਾਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਵਪਾਰਾਂ ਬਾਰੇ ਸਪਸ਼ਟ ਭਾਸ਼ਾ ਦਿਓ ਅਤੇ ਜਿਥੇ ਸੰਭਵ ਹੋਏ “ਐਪ ਵਰਤਦੇ ਸਮੇਂ ਹੀ” ਨੂੰ ਪਹਿਲਾਂ ਚੁਣਨ ਲਈ ਆਫਰ ਕਰੋ।
ਛੋਟੇ ਟੈਮਪਲੇਟਸ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰੋ ਜੋ ਯੂਜ਼ਰ ਤੁਰੰਤ اپنا ਸਕਦੇ ਹਨ:
ਟੈਮਪਲੇਟਸ ਸਿਖਾਉਂਦੇ ਹਨ ਕਿ “ਚੰਗੇ ਰਿਮਾਈਂਡਰ” ਉਦਾਹਰਣ ਕੀ ਹੁੰਦੇ ਹਨ—ਛੋਟੇ, ਕਾਰਵਾਈਯੋਗ, ਅਤੇ ਬਹੁਤ ਵਾਰ ਨਾ ਹੋਣ ਵਾਲੇ।
onboarding ਦੌਰਾਨ, ਇੱਕ ਪਸੰਦੀਦਾ ਚੁਪ ਵਿੰਡੋ ਪੁੱਛੋ (ਉਦਾਹਰਣ ਲਈ ਸ਼ਾਮ ਜਾਂ ਸੌਣ ਦਾ ਸਮਾਂ) ਅਤੇ ਤੁਹਾਡੇ ਡਿਫਾਲਟ ਸੀਮਾਵਾਂ ਦੱਸੋ: “ਅਸੀਂ X ਰਿਮਾਈਂਡਰ ਪ੍ਰਤੀ ਦਿਨ ਤੋਂ ਵੱਧ ਨਹੀਂ ਭੇਜਾਂਗੇ ਜੇ ਤੱਕ ਤੁਸੀਂ ਹੋਰ ਨਹੀਂ ਚੁਣਦੇ।”
ਪਹਿਲੇ-ਦੌਰ ਅਨੁਭਵ ਵਿੱਚ ਇੱਕ ਪ੍ਰਸਿੱਧ Pause reminders ਵਿਕਲਪ ਸ਼ਾਮਿਲ ਕਰੋ। ਯੂਜ਼ਰ ਨੂੰ ਐਸਕੇਪ ਹੈਚ ਦਿੱਤੀਆਂ ਜਾਣ ਤਾਂ ਉਹਨਾਂ ਦੀ ਚਿੰਤਾ ਘੱਟ ਹੁੰਦੀ ਹੈ—ਅਤੇ ਉਹ ਨੋਟੀਫਿਕੇਸ਼ਨ ਚਾਲੂ ਕਰਨ ਲਈ ਵਧੇਰੇ ਤਿਆਰ ਹੁੰਦੇ ਹਨ।
ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਤਦ ਹੀ ਜਾਦੂਈ ਮਹਿਸੂਸ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਉਹ ਸਬੰਧਿਤ ਰਹਿੰਦੇ ਹਨ। ਸਭ ਤੋਂ ਤੇਜ਼ ਰਸਤਾ ਹੈ ਕਿ ਆਪਣੀ ਲਾਜਿਕ ਨੂੰ "ਸੈਟ ਅਤੇ ਭੁੱਲੋ" ਨਾ ਛੱਡੋ—ਸਦੀਵ ਤੌਰ 'ਤੇ ਮਾਪੋ ਅਤੇ ਸੁਧਾਰੋ।
ਇੱਕ ਛੋਟੀ, ਸਥਿਰ ਇਵੈਂਟ ਸਕੀਮਾ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਸਮੇਂ ਦੇ ਨਾਲ ਤਬਦੀਲੀਆਂ ਦੀ ਤੁਲਨਾ ਕਰ ਸਕੋ। ਘੱਟੋ-ਘੱਟ ਟਰੈਕ ਕਰੋ:
ਇਨ੍ਹਾਂ ਨੂੰ ਸੰਦਰਭ ਮੈਟਾਡੇਟਾ ਨਾਲ ਜੋੜੋ (ਟ੍ਰਿਗਰ ਕਿਸਮ, ਸਮਾਂ ਵਿੰਡੋ, ਬੰਡਲ ਵਗੈਰਾ) ਤਾਂ ਜੋ ਤੁਸੀਂ ਦੇਖ ਸਕੋ ਕਿ ਕੀ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ—ਸਿਰਫ਼ ਭੇਜਿਆ ਨਹੀਂ।
ਓਵਰਲੋਡ ਅਕਸਰ ਪਰੋਕਸੀ ਰੂਪ ਵਿੱਚ ਆਉਂਦਾ ਹੈ। ਰੁਝਾਨਾਂ ਤੇ ਧਿਆਨ ਦਿਓ—ਉਚ ਡਿਸਮਿਸ ਦਰ, ਤੇਜ਼ “ਮਿਊਟ ਆਲ” ਕਾਰਵਾਈਆਂ, ਆਗਿਆ ਰੱਦ, ਐਪ ਖੁਲ੍ਹਣਾਂ 'ਚ ਘਟੋਤਰੀ ਪਹਿਲੇ ਹਫ਼ਤੇ ਬਾਅਦ। ਇਹ ਤੁਹਾਡੇ ਸਿੰਗਲ-ਅਲਾਰਮ ਹਨ; ਸਪੋਰਟ ਟਿਕਟਾਂ ਦੀ ਉਡੀਕ ਨਾ ਕਰੋ।
ਹਰੇਕ ਵੈਰੀਏਬਲ ਨੂੰ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਟੈਸਟ ਕਰੋ ਅਤੇ "ਮਦਦਗਾਰ" ਮੈਟਰਿਕ ਪਹਿਲਾਂ ਤੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਸਿਰਫ਼ open rates ਨਹੀਂ)। ਵਰਤਮਾਨ ਪ੍ਰਯੋਗ: ਟਾਈਮਿੰਗ ਵਿੰਡੋਜ਼, ਕਾਪੀ ਟੋਨ ਅਤੇ ਲੰਬਾਈ, ਬੰਡਲਿੰਗ ਨਿਯਮ, ਦਿਨ/ਸਪਤੀ ਕੈਪ। ਇੱਕ ਚੰਗਾ ਰਿਮਾਈਂਡਰ ਘੱਟ open rate ਹੋ ਸਕਦੀ ਹੈ ਪਰ ਉਹ snoozes ਅਤੇ ਦੁਹਰਾਈਆਂ dismissals ਨੂੰ ਘਟਾ ਸਕਦਾ ਹੈ।
ਮੁੱਖ ਇੰਟਰਐਕਸ਼ਨਾਂ—ਜਿਵੇਂ ਡਿਸਮਿਸ ਦੀ ਲੜੀ ਜਾਂ ਮਿਊਟ ਕਾਰਵਾਈ—ਤੋਂ ਬਾਅਦ ਇੱਕ-ਟੈਪ ਪ੍ਰਸ਼ਨ ਪੁੱਛੋ: “ਗੈਰ-ਸੰਬੰਧਿਤ”, “ਬੁਰਾ ਸਮਾਂ”, “ਬਹੁਤ ਵਾਰ”, ਜਾਂ “ਹੋਰ”。 ਇਹ ਵੈਚਣਿਕ ਬੇਨਤੀ ਹੋਵੇ ਅਤੇ ਜਵਾਬਾਂ ਨੂੰ ਨਿਯਮ, ਪ੍ਰਾਇਓਰਿਟੀ, ਅਤੇ ਮਿਆਦ ਟਿਊਨ ਕਰਨ ਲਈ ਵਰਤੋ—ਹੋਰ ਨੋਟੀਫਿਕੇਸ਼ਨ ਨਾ ਜੋੜੋ।
ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਤਦ ਹੀ “ਸਮਾਰਟ” ਮਹਿਸੂਸ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਉਹ ਹਰ ਕਿਸੇ ਅਤੇ ਹਰ ਜਗ੍ਹਾ ਲਈ ਕੰਮ ਕਰਨ, ਅਤੇ ਜਦੋਂ ਰੁਕਾਵਟਾਂ ਖਤਰਨਾਕ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਨ੍ਹਾਂ ਏਜ ਕੇਸਾਂ ਨੂੰ ਪਹਿਲੋਂ ਹੀ ਡਿਜ਼ਾਇਨ ਕਰਨਾ ਬਾਅਦ ਦੇ ਮੁੜ-ਕਾਮ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ।
पूरੇ ਰਿਮਾਈਂਡਰ ਫਲੋ ਨੂੰ ਸਕ੍ਰੀਨ ਰੀਡਰਾਂ (VoiceOver/TalkBack) ਨਾਲ ਟੈਸਟ ਕਰੋ: ਨੋਟੀਫਿਕੇਸ਼ਨ ਟੈਕਸਟ, ਕਾਰਵਾਈ ਬਟਨ, ਅਤੇ ਟੈਪ ਤੋਂ ਬਾਅਦ ਖੁੱਲ੍ਹਣ ਵਾਲੀ ਸਕਰੀਨ। ਸੁਰਗਰਾਂ ਲਾਕੜੀ ਜੈਸੇ ਅੰਦਾਜ਼ ਦੇ ਬਿਨਾਂ ਕਾਰਵਾਈਆਂ ਲਈ ਸੁਲਭ ਬਣਾਓ।
ਵੱਡੀ ਟੈक्सਟ ਅਤੇ ਡਾਇਨਾਮਿਕ ਟਾਈਪ ਸਹਾਇਤਾ ਕਰੋ ਤਾਂ ਰਿਮਾਈਂਡਰ ਸਿਰਲੇਖ ਅਜਿਹੇ ਨਾ ਕਟ ਜਾਣ ਕਿ ਉਨ੍ਹਾਂ ਦਾ ਅਰਥ ਅਸਪਸ਼ਟ ਹੋ ਜਾਵੇ। ਭਾਸ਼ਾ ਸਕੈਨੇਬਲ ਰੱਖੋ: ਇੱਕ ਛੋਟਾ ਸਿਰਲੇਖ ਅਤੇ ਇੱਕ ਸਪਸ਼ਟ ਅਗਲਾ ਕਦਮ।
ਰੰਗ-ਕੌਂਟ੍ਰਾਸਟ ਅਤੇ ਸਟੇਟ ਇੰਡਿਕੇਟਰ ਵੀ ਜਾਂਚੋ। ਜੇ ਤੁਸੀਂ ਪ੍ਰਾਥਮਿਕਤਾ ਜਾਂ ਵਰਗ ਦਰਸਾਉਣ ਲਈ ਰੰਗ ਵਰਤਦੇ ਹੋ, ਤਾਂ ਦੂਜਾ ਇਸ਼ਾਰਾ (ਆਈਕਾਨ, ਲੇਬਲ, ਜਾਂ ਟੈਕਸਟ) ਦਿਓ ਤਾਂ ਕਿ ਰੰਗ-ਬਲਾਈਂਡ ਉਪਭੋਗਤਿਆਂ ਲਈ ਭੀ ਅਰਥ ਰਿਹਾ ਰਿਹਾ।
ਸਮਾਂ ਅਤੇ ਤਾਰੀਖ ਫਾਰਮੈਟ ਆਪਣੇ-ਆਪ ਵਿੱਚ ਲੁਕਲਾਈਜ਼ ਕਰੋ (12/24-ਘੰਟੇ, ਹਫ਼ਤੇ ਦੀ ਸ਼ੁਰੂਆਤ), ਅਤੇ ਸਬੰਧਤ ਸਮਾਂ-phrasing ਨੂੰ ਸਥਾਨਿਕ ਰੂਪ ਵਿੱਚ ਢਾਲੋ। ਰਿਮਾਈਂਡਰ ਕਾਪੀ ਵਿੱਚ ਮੁਹਾਵਰੇ ਅਤੇ ਸਲੈਂਗ ਤੋਂ ਬਚੋ—ਉਹ ਇੱਕ ਖੇਤਰ ਵਿੱਚ ਦੋਸਤਾਨਾ ਲੱਗ ਸਕਦੇ ਹਨ ਪਰ ਦੂਜੇ ਵਿੱਚ ਗਲਤ ਜਾਂ ਹੜਤਾਲੀ ਲੱਗ ਸਕਦੇ ਹਨ।
ਲੰਬੇ ਭਾਸ਼ਾਵਾਂ (ਜਿਵੇਂ ਜਰਮਨ) ਵਿੱਚ ਟੈਕਸਟ ਲਈ ਕਮਰਾ ਬਣਾਓ, ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਬਹੁਵਚਨ ਅਤੇ ਜੈਂਡਰਡ ਭਾਸ਼ਾ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਰੈਂਡਰ ਕਰ ਰਹੀ ਹੈ।
ਸ਼ਿਫਟ ਵਰਕਰਾਂ ਦੀ ਨੀਂਦ ਅਜਿਹੇ ਸਮੇਂ ਹੋ ਸਕਦੀ ਹੈ—ਚੁਪ ਘੰਟੇ ਕਸਟਮਾਇਜ਼ੇਬਲ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ ਅਤੇ ਰਾਤ ਨੂੰ ਮੰਨਣ ਨਹੀਂ। ਯਾਤਰਾ ਅਤੇ ਟਾਈਮ ਜ਼ੋਨ “9 AM” ਰਿਮਾਈਂਡਰ ਨੂੰ ਤੋੜ ਸਕਦੇ ਹਨ; ਨਿਰਣਾ ਕਰੋ ਕਿ ਰਿਮਾਈਂਡਰ ਡਿਵਾਈਸ ਦੀ ਮੌਜੂਦਾ ਟਾਈਮ ਜ਼ੋਨ ਨੂੰ ਫਾਲੋ ਕਰਨਗੇ ਜਾਂ ਮੂਲ ਇਕਾਈ 'ਤੇ ਟਿਕੇ ਰਹਿਣਗੇ, ਅਤੇ ਇਹ ਚੋਣ ਸਪਸ਼ਟ ਦੱਸੋ।
ਸਾਂਝੇ ਡਿਵਾਈਸ ਜੋਖਮ ਜੋੜਦੇ ਹਨ: ਨੋਟੀਫਿਕੇਸ਼ਨ ਨਿੱਜੀ ਸਮੱਗਰੀ ਉਤਪੰਨ ਕਰ ਸਕਦੇ ਹਨ। ਡਿਸਕ੍ਰੀਟ ਨੋਟੀਫਿਕੇਸ਼ਨ ਸਮੱਗਰੀ ਦੇ ਵਿਕਲਪ ਦਿਓ (ਜਿਵੇਂ "ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਰਿਮਾਈਂਡਰ ਹੈ") ਅਤੇ ਵੇਰਵਾ ਵੇਖਣ ਲਈ ਅਨਲਾਕ ਦੀ ਲੋੜ ਰੱਖੋ।
“ਡਰਾਈਵਿੰਗ” ਜਾਂ “Do Not Disturb” ਹਾਲਤਾਂ ਦੀ ਸਤਿਕਾਰ ਕਰੋ ਜਿੱਥੇ ਸੰਭਵ ਹੋਵੇ, ਅਤੇ ਐਸੇ ਇੰਟਰਐਕਟਿਵ ਪ੍ਰੰਪਟ ਤੋਂ ਬਚੋ ਜੋ ਚੱਲਦੇ ਸਮੇਂ ਫੋਨ ਦੀ ਵਰਤੋਂ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਨ। ਮੈਡੀਕਲ ਜਾਂ ਤਤਕਾਲ ਰਿਮਾਈਂਡਰਾਂ ਲਈ ਇੱਕ ਵਿਕਲਪੀ ਐਸਕੇਲੇਸ਼ਨ ਰਾਹ (X ਮਿੰਟਾਂ ਬਾਅਦ ਦੁਹਰਾਉ, ਤੇਜ਼ ਚੈਨਲ) ਰੱਖੋ ਪਰ ਇਸਨੂੰ opt-in ਰੱਖੋ ਅਤੇ ਸਪਸ਼ਟ ਚੇਤਾਵਨੀਆਂ ਦੇਵੀ—ਝੂਠੀ ਤਤਕਾਲਤਾ ਤੇਜ਼ੀ ਨਾਲ ਭਰੋਸਾ ਘਟਾ ਦਿੰਦੀ ਹੈ।
ਸੰਦਰਭਿਕ ਰਿਮਾਈਂਡਰ ਪ੍ਰਣਾਲੀ ਤੇਜ਼ੀ ਨਾਲ ਵੱਡੀ ਹੋ ਸਕਦੀ ਹੈ: ਵਧੇਰੇ ਸਿਗਨਲ, ਹੋਰ ਸੈਟਿੰਗਾਂ, ਹੋਰ ਏਜ ਕੇਸ। ਓਵਰਲੋਡ ਤੋਂ ਬਚਣ ਲਈ ਸਭ ਤੋਂ ਅਸਾਨ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਤੰਗ ਰੇਂਜ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, ਕੁਝ ਭਰੋਸੇਯੋਗ ਚੀਜ਼ ਸ਼ਿਪ ਕਰੋ, ਅਤੇ ਫਿਰ ਕੇਵਲ ਉਨ੍ਹਾਂ ਸਮਾਂਵਾਂ ਨੂੰ ਵਧਾਓ ਜਦੋਂ ਉਪਭੋਗਤਾ ਵਿਹਤ ਹੈ।
ਇੱਕ ਉੱਚ-ਫ੍ਰਿਕੈਂਸੀ ਸਨਾਰੀਓ ਚੁਣੋ ਜਿੱਥੇ “ਟਾਈਮਿੰਗ + ਸੰਦਰਭ” ਇੱਕ ਬੇਸਿਕ ਅਲਾਰਮ ਤੋਂ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਵਧੀਆ ਹੋ:
MVP ਸੀਮਾਵਾਂ ਪਹਿਲਾਂ ਹੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ:
ਸਫਲਤਾ ਮਿਆਰੀ (ਉਦਾਹਰਣ: ਪੂਰਨਤਾ ਦਰ, ਡਿਸਮਿਸ ਦਰ, ਯੂਜ਼ਰ ਓਪਟ-ਆਊਟ) ਮਾਪਯੋਗ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ—“ਉਪਭੋਗਤਾ ਓਸ ਨੂੰ ਪਸੰਦ ਕਰਦੇ ਹਨ” ਨਹੀਂ।
ਜੇ ਤੁਸੀਂ ਤੇਜ਼ੀ ਨਾਲ ਸਕੋਪ ਨੂੰ ਵੈਰੀਫਾਈ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ Koder.ai ਵਰਤਕੇ MVP ਬਣਾਉਣਾ ਪ੍ਰਾਇਆਕਟਿਕਲ ਹੋ ਸਕਦਾ ਹੈ: ਤੁਸੀਂ ਚੈਟ ਰਾਹੀਂ ਰਿਮਾਈਂਡਰ ਫ਼ਲੋਜ਼ ਪ੍ਰੋਟੋਟਾਈਪ ਕਰ ਸਕਦੇ ਹੋ, React UI ਉੱਤੇ ਇਟਰੇਟ ਕਰੋ, ਅਤੇ triggers/ਆਡਿਟ ਇਵੈਂਟਾਂ ਲਈ Go/PostgreSQL ਮਾਡਲ ਤਿਆਰ ਕਰੋ—ਫਿਰ ਜਦੋਂ ਤਿਆਰ ਹੋਵੋ ਤਾਂ ਸੋਰਸ ਕੋਡ ਨਿਕਾਸ ਕਰੋ।
ਜਦੋਂ MVP ਸਥਿਰ ਹੋ ਜਾਵੇ, ਛੋਟੇ, ਟੈਸਟੇਬਲ ਕਦਮਾਂ ਵਿੱਚ ਵਾਧਾ ਕਰੋ:
ਹਰ ਵਾਧਾ ਆਪਣੀ ਜਗ੍ਹਾ ਕਿਮਤ ਕਮਾਉਣੀ ਚਾਹੀਦੀ ਹੈ—ਟੈਪ ਘਟਾਉਣੀ, ਪੂਰਨਤਾ ਸੁਧਾਰਨੀ, ਜਾਂ ਨੋਟੀਫਿਕੇਸ਼ਨ ਮਾਤਰਾ ਘਟਾਉਣੀ।
ਰਿਮਾਈਂਡਰਾਂ ਨੂੰ ਇੱਕ ਕੋਰ ਭਰੋਸੇਯੋਗ ਫੀਚਰ ਵਜੋਂ ਸੰਜੋ:
ਅਖੀਰਕਾਰ, ਸਹਾਇਤਾ ਸਧਾਰਨ ਬਣਾਓ: ਇਨ-ਐਪ “ਖਰਾਬ ਰਿਮਾਈਂਡਰ ਰਿਪੋਰਟ ਕਰੋ” ਰਾਹ ਅਤੇ ਇੱਕ ਲਘੁ-ਭਾਰ ਫੀਡਬੈਕ ਲੂਪ ਜੋ ਸਿੱਧਾ ਟ੍ਰਾਇਜ, ਪ੍ਰਯੋਗ, ਅਤੇ ਰੋਡਮੈਪ ਫੈਸਲਿਆਂ ਵਿੱਚ ਖਪਦਾ ਹੈ।
ਸਰਲ-ਭਾਸ਼ਾ ਨਤੀਜੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ: ਸਹੀ ਲੋਕ ਨੂੰ, ਸਹੀ ਸਮੇਂ, ਘੱਟ-ਸੁਖਾਵਟੇ ਵਿੱਛੇ ਯਾਦ ਦਿਵਾਉਣਾ। ਫਿਰ 2–3 ਮਾਪਣਯੋਗ ਸਫਲਤਾ ਮੈਟਰਿਕ ਲਿਖੋ (ਜਿਵੇਂ ਕਿ ਰਿਮਾਈਂਡਰ ਤੋਂ ਬਾਅਦ ਪੂਰਾ ਹੋਣਾ, ਸਨੂਜ਼ ਵਿਰੁੱਧ ਡਿਸਮਿਸ, ਓਪਟ-ਆਊਟ) ਅਤੇ ਹਰ ਇਕ ਸੰਦਰਭਿਕ ਸਿਗਨਲ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦੇਖੋ ਕਿ ਉਹ ਉਨ੍ਹਾਂ ਮੈਟਰਿਕਾਂ ਨੂੰ ਸੁਧਾਰੇ—ਸਿਰਫ਼ “ਸਮਾਰਟ” ਜੋੜਨ ਲਈ ਨਹੀਂ।
“ਸੰਦਰਭ” ਉਹ ਸਿਗਨਲਾਂ ਦਾ ਸੈੱਟ ਹੈ ਜੋ ਤੁਸੀਂ ਫੈਸਲਾ ਕਰਨ ਲਈ ਵਰਤਦੇ ਹੋ ਕਿ ਕਦੋਂ ਅਤੇ ਕਿਵੇਂ ਯਾਦ ਦਿਵਾਉਣਾ ਹੈ—ਸਭ ਤੋਂ ਆਮ ਹਨ:
ਇੱਕ ਛੋਟਾ, ਵਿਵਰਣਯੋਗ ਸੈੱਟ ਚੁਣੋ ਜੋ ਤੁਸੀਂ ਸਮਝਾ ਅਤੇ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਸਪੋਰਟ ਕਰ ਸਕੋ।
ਉੱਚ-ਮੁੱਲ ਅਤੇ ਘੱਟ-ਘੇਰਾਵਲੇ ਸਿਗਨਲਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਸਿਰਫ਼ ਉਦੋਂ ਵਧਾਓ ਜਦੋਂ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਸਪਸ਼ਟ ਲਾਭ ਦਿੱਸੇ:
ਜੇਕਰ ਕੋਈ ਸਿਗਨਲ ਵਾਸਤਵਿਕ ਤੌਰ 'ਤੇ ਟਾਈਮਿੰਗ ਸੁਧਾਰਦਾ ਨਹੀਂ ਜਾਂਉ ਦੱਸ ਨਹੀਂ ਕਰਦਾ, ਤਾਂ ਉਸਨੂੰ ਛੱਡ ਦਿਓ।
ਲੋੜ ਦੇ ਸਮੇਂ ਤੇ ਮਕਸਦ-ਵਾਰ ਅਨੁਮਤੀ ਮੰਗੋ ਅਤੇ ਲਾਭ ਸਪਸ਼ਟ ਦਿਖਾਓ:
ਜੇਕਰ ਤੁਸੀਂ ਬਿਨਾਂ ਆਗਿਆ ਦੇ ਕੀਮਤੀ ਸੇਵਾ ਦੇ ਸਕਦੇ ਹੋ, ਪਹਿਲਾਂ ਉਹ ਦਿਓ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਪੂਛੋ—ਜਦੋਂ ਉਪਭੋਗਤਾ ਫੀਚਰ ਨੂੰ ਸਮਝ ਚੁੱਕਾ ਹੋਵੇ।
ਹਮੇਸ਼ਾ ਤੁਰੰਤ ਕੰਟਰੋਲ ਦਿੱਤੇ ਜਾਣ—ਪੌਜ਼, ਮਿਊਟ, ਜਾਂ ਰੱਦ ਕਰਨ ਦੇ ਢੰਗ ਬਿਨਾ ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਝਲਕਣ ਤੋਂ।
ਹਰ ਰਿਮਾਈਂਡਰ ਨੂੰ ਇੱਕ ਸਥਿਰ ਬਿਲਡਿੰਗ ਬਲਾਕ ਦੇ ਰੂਪ ਵਿੱਚ ਮਾਡਲ ਕਰੋ:
ਇਹ “ਰਹਸਮੀ ਲਾਜਿਕ” ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ ਅਤੇ ਟੈਮਪਲੇਟਸ/UI ਵਿੱਚ ਪੇਸ਼ਗੀਹੀਨਤਾ ਰੱਖਦਾ ਹੈ।
ਰੋਕ-ਟੋਕੇ ਨਿਯਮਾਂ ਵਰਤੋ ਜੋ ਪ੍ਰਤੀਤ ਕਰਦੇ ਹਨ ਕਿ ਘੱਟ ਬੇਲੋੜ ਵਧੀਆ ਹਨ:
ਘਣੇ, ਘੱਟ-ਭਰੋਸੇਯੋਗ ਰਿਮਾਈਂਡਰਾਂ ਦੀ ਬਜਾਏ ਘੱਟ ਪਰ ਉੱਚ-ਭਰੋਸੇਯੋਗ ਯਾਦ ਦਿਵਾਓ।
ਹਰ ਨੋਟੀਫਿਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਛੋਟੀ ਫੈਸਲਾ ਸਕ੍ਰੀਨ ਬਣਾਓ ਜੋ ਤਿੰਨ ਸਵਾਲਾਂ ਨੂੰ ਸਾਫ਼ ਕਰੇ:
ਕਾਰਵਾਈਆਂ 2–3 ਤੱਕ ਸੀਮਿਤ ਰੱਖੋ (Done, Snooze, Open). ਟੋਨ ਨਿਰਪੱਖ ਅਤੇ ਸਹਾਇਕ ਰੱਖੋ; ਦਬਾਅ-ਜਨਕ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਦੂਰ ਕਰਦਾ ਹੈ।
ਇਨ-ਐਪ “ਕਿਉਂ ਤੁਸੀਂ ਇਹ ਵੇਖ ਰਹੇ ਹੋ” ਪੈਨਲ ਬਣਾਓ ਜੋ ਦਿਖਾਵੇ:
ਇਸਦੇ ਨਾਲ ਤੁਰੰਤ ਟਿਊਨਿੰਗ ਵਿਕਲਪ ਦਿਓ (Mute for today, Less like this, Only at this place). ਜੇ ਉਪਭੋਗਤਾ 1–2 ਟੈਪ ਵਿੱਚ ਸਮਝ ਕੇ ਅਨੁਕੂਲਤਾ ਕਰ ਸਕਦਾ ਹੈ, ਤਾਂ ਉਹ ਹੋਰ ਸੰਦਰਭਿਟ ਨੋਟੀਫਿਕੇਸ਼ਨਾਂ ਨੂੰ ਭਰੋਸਾ ਨਾਲ ਕਬੂਲ ਕਰਨਗੇ।
ਫਾਲਬੈਕ ਅਤੇ ਨਰਮ ਘਟਾਓ ਦੇਣ ਵਾਲੀ ਯੋਜਨਾ ਬਣਾਓ:
ਅਤੇ ਦਿਓ: ਦਿਡੂਪ ID, ਬੈਕਆਫ਼ ਰੀਟ੍ਰਾਈਜ਼ ਅਤੇ ਓਫਲਾਈਨ-ਫਰਸਟ ਸ਼ੈਡਿਊਲਿੰਗ ਤਾਂ ਜੋ ਇਕੋ gebeurtenis ਲਈ ਕਈ ਪਿੰਗ ਨਾ ਭੇਜੇ ਜਾਣ।
ਪੂਰੇ ਰਿਮਾਈਂਡਰ ਲਾਈਫਸਾਈਕਲ ਨੂੰ ਇੰਸਟ੍ਰੂਮੈਂਟ ਕਰੋ ਅਤੇ “ਓਵਰਲੋਡ” ਨੂੰ ਮਾਪੋ:
ਓਵਰਲੋਡ ਦੇ ਇঙ্গੇ ਹੌਲੇ-ਹੌਲੇ ਚਿੰਨ੍ਹਾਂ ਨੂੰ ਵੇਖੋ: ਉੱਚ ਡਿਸਮਿਸ ਦਰ, ਤੇਜ਼ “ਮਿਊਟ ਆਲ” ਕਾਰਵਾਈ, ਆਗਿਆ ਰੱਦ ਹੋਣਾ, ਜਾਂ ਨੋਟੀਫਿਕੇਸ਼ਨ ਦੇ ਬਾਅਦ ਐਪ ਅਨਇੰਸਟਾਲ। A/B ਟੈਸਟਾਂ ਵਿਚ ਟਾਈਮਿੰਗ, ਕਾਪੀ, ਬੰਡਲਿੰਗ ਅਤੇ ਕੈਪਾਂ ਵਰਗੇ ਇੱਕ-ਵੈਰੀਏਬਲ ਪ੍ਰਯੋਗ ਕਰੋ। ਛੋਟੀ-ਟੈਪ ਫੀਡਬੈਕ (“ਬੁਰਾ ਸਮਾਂ”, “ਬਹੁਤ ਤੇਜ਼”, “ਗੈਰ-ਸੰਬੰਧਿਤ”) ਬੇਨਤੀ ਕਰਨ 'ਤੇ ਦਿਖਾਓ।