ਫੁੱਲ ਸਟੈਕ ਡਿਵੈਲਪਰਇੰਟਰਵਿਊ ਜਵਾਬ

ਮੇਰੀ ਮੁੱਖ ਸਟੈਕ [React / Next.js ਨੂੰ frontend 'ਤੇ, Node.js / Express ਜਾਂ Python / Django / FastAPI ਨੂੰ backend 'ਤੇ, PostgreSQL ਜਾਂ MongoDB ਡੇਟਾ ਲਈ, ਅਤੇ AWS ਜਾਂ GCP 'ਤੇ ਡਿਪਲੋਇਡ] ਹੈ। frontend 'ਤੇ ਮੈਨੂੰ state management (Redux, Zustand, ਜਾਂ Context), responsive design, component architecture, ਅਤੇ performance optimisation (lazy loading, code splitting) ਦਾ ਤਜਰਬਾ ਹੈ। backend 'ਤੇ ਮੈਂ RESTful ਅਤੇ GraphQL APIs ਬਣਾਉਂਦਾ ਹਾਂ, authentication ਲਾਗੂ ਕਰਦਾ ਹਾਂ (JWT, OAuth), ਅਤੇ database schemas ਡਿਜ਼ਾਇਨ ਕਰਦਾ ਹਾਂ। ਮੈਂ Docker ਨਾਲ containerisation ਅਤੇ ਬੁਨਿਆਦੀ CI/CD pipeline configuration ਵਿੱਚ ਆਰਾਮਦਾਇਕ ਹਾਂ.

ਮੈਂ requirements ਨੂੰ ਸਪੱਸ਼ਟ ਕਰਨ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦਾ ਹਾਂ — ਯੂਜ਼ਰ ਦੀ ਲੋੜ ਅਤੇ acceptance criteria ਨੂੰ ਸਮਝਣਾ ਪਹਿਲਾਂ ਜਿਥੋਂ ਕੋਈ ਕੋਡ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ। ਪਹਿਲਾਂ data model ਡਿਜ਼ਾਇਨ ਕਰਦਾ/ਕਰਦੀ ਹਾਂ, ਫਿਰ API contract, ਅਤੇ ਫਿਰ frontend components। ਮੈਂ ਸਭ ਤੋਂ ਪਹਿਲਾਂ backend ਬਣਾਉਂਦਾ/ਬਣਾਉਂਦੀ ਹਾਂ ਅਤੇ unit tests ਲਿਖਦਾ/ਲਿਖਦੀ ਹਾਂ, ਫਿਰ frontend ਜੋ API ਨੂੰ ਖਪਾਉਂਦਾ ਹੈ ਉਸਨੂੰ ਬਣਾਉਂਦਾ/ਬਣਾਉਂਦੀ ਹਾਂ। ਵਿਕਾਸ ਵਿੱਚ ਪੂਰੇ flow ਦੀ ਜਾਂਚ ਕਰਦਾ/ਕਾਰਦੀ ਹਾਂ, critical paths ਲਈ integration tests ਲਿਖਦਾ/ਲਿਖਦੀ ਹਾਂ, ਅਤੇ PR ਭੇਜਣ ਤੋਂ ਪਹਿਲਾਂ ਆਪਣੀ ਕੋਡ-ਸਮੀਖਿਆ ਕਰਦਾ/ਕਰਦੀ ਹਾਂ। ਮੈਂ edge cases, error states, ਅਤੇ loading states ਨੂੰ ਫੀਚਰ ਦਾ ਹੀ ਹਿੱਸਾ ਮੰਨਦਾ/ਮੰਦੀ ਹਾਂ, ਨਾ ਕਿ ਬਾਅਦ ਦਾ ਵਿਚਾਰ।

ਮੈਂ optimising ਤੋਂ ਪਹਿਲਾਂ profiling ਕਰਦਾ/ਕਰਦੀ ਹਾਂ — ਇਹ ਪਛਾਣਨ ਲਈ ਕਿ ਬੌਟਲਨੇਕ frontend (render performance, bundle size, network) ਹੈ ਜਾਂ backend (slow queries, N+1 issues, blocking I/O)। frontend 'ਤੇ ਮੈਂ Chrome DevTools ਅਤੇ Lighthouse ਵਰਤਦਾ/ਵਰਤਦੀ ਹਾਂ: bundle analysis (webpack-bundle-analyzer), routes ਅਤੇ components ਲਈ lazy loading, image optimisation, ਅਤੇ caching ਤਕਨੀਕਾਂ। backend 'ਤੇ ਮੈਂ APM tools (Datadog, New Relic) ਵਰਤਦਾ/ਵਰਤਦੀ ਹਾਂ, database optimisation ਲਈ query explain plans ਵੇਖਦਾ/ਵੇਖਦੀ ਹਾਂ, caching (Redis) ਅਤੇ ਭਾਰੀ operations ਲਈ async processing ਵਰਤਦਾ/ਵਰਤਦੀ ਹਾਂ। Premature optimisation ਇੱਕ ਫੰਦ ਹੈ — ਮੈਂ ਪਹਿਲਾਂ ਮਾਪਦਾ/ਮਾਪਦੀ ਹਾਂ।

ਮੈਂ schemas ਨੂੰ ਇਟਰੈਟਿਵ ਤਰੀਕੇ ਨਾਲ ਡਿਜ਼ਾਇਨ ਕਰਦਾ/ਕਰਦੀ ਹਾਂ ਪਰ query patterns ਨੂੰ ਆਗੇ ਦੇਖ ਕੇ। ਡਿਫਾਲਟ ਵਜੋਂ ਮੈਂ 3NF ਤੱਕ normalise ਕਰਦਾ/ਕਰਦੀ ਹਾਂ, ਪਰ performance-critical read paths ਲਈ ਸਾਵਧਾਨੀ ਨਾਲ denormalise ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਮੈਂ ਅਸਲ query patterns ਦੇ ਆਧਾਰ 'ਤੇ indexes ਜੋੜਦਾ/ਜੋੜਦੀ ਹਾਂ — ਹਰ index ਲਿਖਣ ਵੇਲੇ ਖਰਚ ਵਧਾਉਂਦਾ/ਵਧਾਉਂਦੀ ਹੈ। ਮੈਂ migration scripts ਧਿਆਨ ਨਾਲ ਲਿਖਦਾ/ਲਿਖਦੀ ਹਾਂ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ ਕਿ ਉਹ reversible ਹਨ ਅਤੇ production ਵਿੱਚ ਟੇਬਲਾਂ ਨੂੰ ਲੌਕ ਨਾ ਕਰਨ। ਮੈਂ data lifecycle ਬਾਰੇ ਵੀ ਸੋਚਦਾ/ਸੋਚਦੀ ਹਾਂ: ਵੱਡੀਆਂ ਟੇਬਲਾਂ ਲਈ archival strategies, soft deletes ਵਿਰੁੱਧ hard deletes, ਅਤੇ ਗੰਭੀਰ ਡੇਟਾ ਲਈ audit logging। ਡੇਟਾ ਮਾਡਲ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ালী ਆਰਕੀਟੈਕਚਰਲ ਫੈਸਲਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ।

ਸੁਰੱਖਿਆ ਨੂੰ ਪਰਤਦਾਰ ਰੱਖਦਾ/ਰੱਖਦੀ ਹਾਂ: XSS ਅਤੇ SQL injection ਰੋਕਣ ਲਈ input validation ਅਤੇ sanitisation, ਸਾਰੇ database operations ਲਈ parameterised queries, ਹਰ ਥਾਂ HTTPS, secure authentication (passwords ਲਈ bcrypt, JWTs ਨਾਲ مناسب expiry, CSRF ਸੁਰੱਖਿਆ), ਸਹੀ CORS configuration, CI ਵਿੱਚ dependency scanning (npm audit, Snyk), ਅਤੇ database ਅਤੇ cloud IAM ਲਈ least-privilege ਨੀਤੀ। ਮੈਂ OWASP Top 10 ਨੂੰ ਇੱਕ ਬੇਸਲਾਈਨ ਵਜੋਂ ਲੈਂਦਾ/ਲੈਂਦੀ ਹਾਂ ਅਤੇ ਹਰ code review checklist ਵਿੱਚ security review ਸ਼ਾਮਲ ਕਰਦਾ/ਕਾਰਦੀ ਹਾਂ। ਸੁਰੱਖਿਆ ਪਹਿਲੇ ਦਿਨ ਤੋਂ ਹੀ ਇੰਜੀਨੀਅਰਿੰਗ ਦੀ ਚਿੰਤਾ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ penetration test ਦੀ ਖੋਜ।

ਮੈਂ design reviews ਵਿੱਚ ਸ਼ੁਰੂ ਤੋਂ ਹੀ ਹਿੱਸਾ ਲੈਂਦਾ/ਲੈਂਦੀ ਹਾਂ ਤਾਂ ਜੋ technical feasibility ਅਤੇ design choices ਦੀ implementation cost ਨੂੰ ਦਰਸਾਇਆ ਜਾ ਸਕੇ — ਮਹਿੰਗੀਆਂ ਫੈਸਲਿਆਂ ਨੂੰ commit ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਚੈੱਕ ਕਰਨਾ। ਜਦੋਂ requirements ਅਸਪਸ਼ਟ ਹੁੰਦੀਆਂ ਹਨ ਤਾਂ sprint planning ਦੌਰਾਨ ਪ੍ਰਸ਼ਨ ਪੁੱਛਦਾ/ਪੁੱਛਦੀ ਹਾਂ, ਬਿਨਾਂ ਅਨੁਮਾਨ ਲਗਾਉਣ ਤੋਂ। ਮੈਂ complexity ਅਤੇ trade-offs ਬਾਰੇ ਸਾਫ਼ ਸੰਚਾਰ ਕਰਦਾ/ਕਰਦੀ ਹਾਂ — PMs ਨੂੰ scope ਬਾਰੇ ਜਾਣੂ ਫੈਸਲਾ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ। ਮੈਂ design 'ਤੇ feedback ਦਿੰਦਾ/ਦਿੰਦੀ ਹਾਂ ਯੂਜ਼ਰ ਐਕਸਪੀਰੀਅਂਸ ਅਤੇ technical constraints ਦੇ ਸੰਦਰਭ ਵਿੱਚ, ਨ ਕਿ ਨਿੱਜੀ ਪਸੰਦ ਦੇ ਤੌਰ 'ਤੇ। ਜਿਹੜੇ full stack ਵਿਕਾਸਕ proactive ਤਰੀਕੇ ਨਾਲ ਪ੍ਰੋਡਕਟ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ ਉਹ ਬਿਹਤਰ ਸਾਫਟਵੇਅਰ ship ਕਰਦੇ ਹਨ।

ਮੈਂ business logic ਲਈ unit tests Jest ਜਾਂ pytest ਨਾਲ ਲਿਖਦਾ/ਲਿਖਦੀ ਹਾਂ। API endpoints ਲਈ integration tests ਲਿਖਦਾ/ਲਿਖਦੀ ਹਾਂ। frontend ਲਈ ਮੈਂ React Testing Library ਨਾਲ component tests ਅਤੇ Cypress ਜਾਂ Playwright ਨਾਲ E2E tests ਵਰਤਦਾ/ਵਰਤਦੀ ਹਾਂ। ਮੈਂ critical paths 'ਤੇ ਉੱਚ ਕਵਰੇਜ ਦਾ ਨਿਸ਼ਾਨਾ ਰੱਖਦਾ/ਰੱਖਦੀ ਹਾਂ ਬਜਾਏ 100% coverage ਲਈ ਦੌੜਣ ਦੇ। ਮੈਂ testing pyramid 'ਤੇ ਵਿਸ਼ਵਾਸ ਕਰਦਾ/ਕਰਦੀ ਹਾਂ: ਬਹੁਤ ਸਾਰੇ unit tests, ਘੱਟ integration tests, ਸਭ ਤੋਂ ਘੱਟ E2E tests। ਮੈਂ ਮਾਇਨੇ ਰੱਖਣ ਵਾਲੇ tests ਲਿਖਦਾ/ਲਿਖਦੀ ਹਾਂ — ਉਹ tests ਜੋ ਅਸਲ regression ਫੜ ਸਕਣ, ਨਾ ਕਿ ਐਸੇ tests ਜੋ implementation ਨੂੰ ਹੀ ਨਕਲ ਕਰਨ।

ਮੈਂ ਸਮਝਣ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦਾ/ਕਰਦੀ ਹਾਂ — ਕੋਡ ਪੜ੍ਹਕੇ, ਉਸਨੂੰ ਚਲਾ ਕੇ, ਅਤੇ ਉਹਨਾਂ ਲੋਕਾਂ ਨਾਲ ਗੱਲ ਕਰਕੇ ਜੋ ਉਸਨੂੰ ਬਣਾਇਆ ਸੀ। ਮੈਂ ਤੁਰੰਤ rewrite ਕਰਨ ਦੀ ਲਾਲਚ ਨੂੰ ਰੋਕਦਾ/ਰੋਕਦੀ ਹਾਂ; ਇਹ ਤਾਂਬੇ ਕਰੀਬਹੀ ਗਲਤ ਹੁੰਦੀ ਹੈ। ਮੈਂ ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਰਿਸਕ ਅਤੇ ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਬਦਲਾਅ ਵਾਲੇ ਖੇਤਰਾਂ ਨੂੰ ਪਛਾਣਦਾ/ਪਛਾਣਦੀ ਹਾਂ — ਇੱਥੇ ਸੁਧਾਰ ਕਰਨ ਦੀ ਸਭ ਤੋਂ ਵੱਧ ਕੀਮਤ ਹੁੰਦੀ ਹੈ। ਮੈਂ ਕੋਡ ਬਦਲਣ ਤੋਂ ਪਹਿਲਾਂ tests ਜੋੜਦਾ/ਜੋੜਦੀ ਹਾਂ ਤਾਂ ਜੋ ਸੁਰੱਖਿਆ ਜਾਲ ਮਿਲੇ। ਮੈਂ ਇੰਕ੍ਰੀਮੈਂਟਲ ਤਰੀਕੇ ਨਾਲ refactor ਕਰਦਾ/ਕਰਦੀ ਹਾਂ: ਇੱਕ ਸਮੇਂ ਇੱਕ ਮੋਡੀਊਲ ਸੁਧਾਰਨਾ ਜਦੋਂ ਕਿ ਸਿਸਟਮ ਕੰਮ ਕਰਦਾ ਰਹੇ। ਮੈਂ ਜਦੋਂ ਜਾ ਰਿਹਾ/ਰਹੀ ਹਾਂ ਤਾਂ ਫੈਸਲਿਆਂ ਅਤੇ patterns ਨੂੰ ਡੌਕੂਮੈਂਟ ਕਰਦਾ/ਕਰਦੀ ਹਾਂ। legacy ਕੋਡ ਅਕਸਰ ਮਹੱਤਵਪੂਰਨ ਬਿਜ਼ਨਸ ਲਾਜਿਕ ਨਾਲ ਭਰਪੂਰ ਹੁੰਦਾ ਹੈ — ਇਸਨੂੰ ਇਜ਼ਤ ਨਾਲ ਸਲੂਕ ਕਰੋ।