all publishers

ahtishamshahzad

@ahtishamshahzad source repo

182 published skills · page 1 of 2

  1. ▌
    Project Orchestrator · ahtishamshahzad
    Use as the lead skill for any non-trivial request. It drives the full request→approval pipeline (classify, audit, requirements, applications, stack, architecture, phases, tasks) and coordinates specialist skills. It plans and delegates; it does not implement every domain itself, and it stops before implementation until gates are approved. After approval it hands the plan to project-management for weekly tracking.
    0 repo stars
  2. ▌
    Stack Recommendation · ahtishamshahzad
    Use after applications are selected to recommend a technology stack per area (mobile, web, backend, database + data layer, testing) with justification and alternatives. Pairs databases with data layers correctly; never compares a database against an ORM. Requires user approval before any code.
    0 repo stars
  3. ▌
    Requirements Analysis · ahtishamshahzad
    Use after classification to extract goals, constraints, users, and success criteria from a request, and to separate confirmed facts from assumptions and open questions. Produces the requirement baseline the rest of the plan depends on.
    0 repo stars
  4. ▌
    Existing Project Audit · ahtishamshahzad
    Use when a codebase already exists, before proposing any changes. It inventories structure, stack, applications present, tests, security posture, and implementation state so planning is grounded in reality rather than assumptions.
    0 repo stars
  5. ▌
    Request Classification · ahtishamshahzad
    Use at the very start of every request to classify it into one of the system's request types. The classification selects the workflow variant, gates, and which specialist skills apply. Run before requirements analysis or any planning.
    0 repo stars
  6. ▌
    Gherkin Specifications · ahtishamshahzad
    Use before designing or coding any behavior change — features, bug fixes, API, UI, mobile, auth, payments, AI — to write the Gherkin scenarios that are its mandatory, approved behavioral contract (system/GHERKIN_RULES.md), then keep them as permanent regression coverage.
    0 repo stars
  7. ▌
    Feature Planning · ahtishamshahzad
    Use to plan a feature work item — scoping new capability within existing (or planned) architecture, defining its phases, tasks, tests, and acceptance criteria without expanding scope. Delegates general phase/task mechanics to task-planning.
    0 repo stars
  8. ▌
    Release Planning · ahtishamshahzad
    Use to validate release readiness and plan a release — tests green, docs and changelog updated, versioning handled, git workflow followed, and any publish/deploy explicitly approved. Enforces Gate 7; never ships on a failed gate.
    0 repo stars
  9. ▌
    Bug Investigation · ahtishamshahzad
    Use to diagnose and plan the fix for a defect — audit, reproduce, find root cause, fix minimally, add a regression test, and validate. Fixes the cause, not the symptom, and pins it so it can't return.
    0 repo stars
  10. ▌
    Refactor Planning · ahtishamshahzad
    Use to plan a behavior-preserving structural improvement — audit the target, ensure test coverage exists, plan small reversible steps, and verify behavior is unchanged. Any intended behavior change is a feature, not a refactor.
    0 repo stars
  11. ▌
    Migration Planning · ahtishamshahzad
    Use to plan a move from one state to another (framework/version/data/schema/infra) safely and incrementally, with a compatibility strategy, per-step verification, a rollback path, and an explicit cutover. Production migrations require approval.
    0 repo stars
  12. ▌
    Architecture Design · ahtishamshahzad
    Use after the stack is approved to define module boundaries, data flow, integration points, and cross-cutting concerns (auth, config, error handling). Produces the architecture that phases and tasks are generated from. Proportional to the request.
    0 repo stars
  13. ▌
    Code Review · ahtishamshahzad
    Use to review a change or diff for correctness, clarity, maintainability, and convention-fit before it advances. Reports findings with severity, separating confirmed defects from suggestions; does not rubber-stamp.
    0 repo stars
  14. ▌
    Task Planning · ahtishamshahzad
    Use to generate dynamic phases and break them into concrete, verifiable tasks with inputs, outputs, acceptance criteria, and dependencies. Produces the implementation plan approved at Gate 4. Phases are derived from real work, never a fixed template.
    0 repo stars
  15. ▌
    Security Review · ahtishamshahzad
    Use to assess a change or codebase for security weaknesses — secrets, auth, authorization/IDOR, injection, PII handling, transport/errors, payments, and production hardening. Reports findings by severity, separates confirmed from potential, never prints secret values, and never claims "secure."
    0 repo stars
  16. ▌
    Dependency Audit · ahtishamshahzad
    Use to inventory and assess a project's dependencies — versions, known vulnerabilities, unused/duplicate packages, license and maintenance risk, and heavy additions. Recommends changes with justification; never bloats the tree "to be safe."
    0 repo stars
  17. ▌
    Project Management · ahtishamshahzad bundle
    Use after plan approval to track work week by week in `.ai/projects/current/` — roadmap, weekly plans, task/bug IDs, bug intake, scope changes, logs, and weekly/meeting reports. Never bypasses approval gates.
    0 repo stars
  18. ▌
    Context Engineering · ahtishamshahzad
    Use at the start of any non-trivial task to assemble the minimum sufficient context — scenarios first, then the relevant skills, files, and tests — escalating only on evidence; also to build context packs for multi-step or multi-agent work, keep stable project summaries fresh, and explain why each item was loaded.
    0 repo stars
  19. ▌
    Technology Governance · ahtishamshahzad
    Use whenever a technology or version is chosen, added, or changed — new-project baselines (latest stable, verified against official version-matched docs, compatible), existing projects (keep what works; upgrade only for security, end of life, a required feature, or compatibility), version drift, deprecations, and technology decision records.
    0 repo stars
  20. ▌
    Payments Subscriptions · ahtishamshahzad
    Use to design one-off payments and recurring subscriptions with a payment provider — plans, seats, trials, upgrades and proration, failed payments and dunning, entitlements, refunds, and keeping your records in sync with the provider through idempotent webhooks.
    0 repo stars
  21. ▌
    Client Guide · ahtishamshahzad
    Use when a client-facing guide to an existing product is wanted — a complete, non-technical, screenshot-backed explanation of every user type, screen, workflow, and admin/CMS module, built from the running application. Asks the blocking questions first, explores the real app, captures genuine screenshots, then produces the Markdown guide and, if requested, a PDF, a presentation artifact, and a separate end-user guide. Documents what exists; never invents.
    0 repo stars
  22. ▌
    Playwright E2e 2 · ahtishamshahzad
    Use to plan web/dashboard end-to-end tests with Playwright — a small set of critical user journeys against a real browser and running app, resilient to timing (auto-wait, no sleeps), covering happy path plus key invalid/error/authorization-denied flows. Reserved for flows that justify E2E cost.
    0 repo stars
  23. ▌
    Database Security 2 · ahtishamshahzad
    Use to review database security from an audit/threat lens — least-privilege access, network exposure, injection surface, encryption of sensitive data, tenant isolation depth, and PII handling — verifying the data-layer hardening holds. The security-review lens; the database pack owns the build-side design.
    0 repo stars
  24. ▌
    Flaky Test Audit · ahtishamshahzad
    Use to find, diagnose, and fix flaky tests — nondeterministic passes/failures from timing, shared state, ordering, real time/randomness, or live externals. Fix the root cause; quarantine only temporarily. A trusted suite is the goal, not a green-by-retry one.
    0 repo stars
  25. ▌
    Web State Management · ahtishamshahzad
    Use to decide where each piece of web app state lives — local component, form, shared client, server cache, URL, or persisted — before picking any state library. URL state is first-class on the web; server data belongs to the server-state layer, not a global store.
    0 repo stars
  26. ▌
    Application Documentation · ahtishamshahzad
    Use to place and maintain the documentation of the applications being built — the `docs/` tree, one folder per app, indexed at every level, with a file per screen, page, endpoint, or job. Distinct from `.ai/`, which holds plans and system rules, not product documentation. Docs ship with the change that causes them.
    0 repo stars
  27. ▌
    Nestjs Foundation · ahtishamshahzad
    Use to plan a NestJS foundation after NestJS is approved — module boundaries, dependency injection, providers, pipes/guards/interceptors/filters, config module, conventions for a multi-developer codebase. Plans only; scaffolds nothing without task approval.
    0 repo stars
  28. ▌
    Mongoose Mongodb · ahtishamshahzad
    Use to plan Mongoose over MongoDB — expressing the approved document design as schemas with real validation, indexes declared and built deliberately, lean queries, middleware discipline, and transactions only where the design demands them.
    0 repo stars
  29. ▌
    Incident Readiness · ahtishamshahzad
    Use to prepare for production incidents — on-call and escalation, severity levels, runbooks for likely failures, alert-to-response wiring, communication paths, and blameless postmortems that feed regression tests. Preparation before incidents, not response during one.
    0 repo stars
  30. ▌
    Monitoring Logging · ahtishamshahzad
    Use to plan production monitoring and logging at the ops level — centralized structured logs, key metrics/dashboards, health checks, symptom-based alerting with ownership, uptime/synthetic checks, and cost/retention — so failures are seen fast. Application instrumentation is backend-observability.
    0 repo stars
  31. ▌
    Monorepo Selection · ahtishamshahzad
    Use when a monorepo is chosen to pick the workspace/tooling — pnpm/npm workspaces alone vs adding Turborepo for task orchestration and caching — based on app count, build complexity, and CI needs. Evaluates rather than defaulting to the heaviest option.
    0 repo stars
  32. ▌
    Secrets Management · ahtishamshahzad
    Use to plan secret storage and handling — a secret store (not git), per-environment separation, least-privilege access, rotation, injection at runtime/CI, and keeping secrets out of code, logs, images, and client bundles. Auditing existing secret exposure is secrets-audit.
    0 repo stars
  33. ▌
    Mobile File Upload · ahtishamshahzad
    Use to plan file uploads from mobile — picking files/images, size/type limits, progress, retries, and secure transfer to storage/backend. Validate on the server; keep uploads off executable paths.
    0 repo stars
  34. ▌
    Mobile Maestro E2e · ahtishamshahzad
    Use to plan Maestro end-to-end tests for critical mobile flows on real device/emulator. Select Maestro when critical mobile E2E flows exist; cover the critical path (auth, checkout, core journeys) rather than every screen.
    0 repo stars
  35. ▌
    Mobile Performance · ahtishamshahzad
    Use to plan and diagnose mobile performance — list rendering, re-renders, image/memory usage, startup, and jank — measured on a representative build. Prefer measured, safe fixes over rewrites. The mobile arm of performance-review.
    0 repo stars
  36. ▌
    Abuse Prevention · ahtishamshahzad
    Use to review whether public and expensive endpoints are protected against automated abuse — rate limiting, CAPTCHA/bot defenses, and cost controls on signup, login, reset, OTP, contact, search, and expensive operations. Verifies abuse defenses hold; distinct from authorization.
    0 repo stars
  37. ▌
    Testing Selection · ahtishamshahzad
    Use to choose which test types and tools a project needs — Playwright (web/dashboard E2E), Maestro (mobile E2E/smoke), Supertest (backend API integration), Testing Library (components), Jest/Vitest (unit + integration logic). Selects only what the project's applications and risks justify; does not adopt every tool by default.
    0 repo stars
  38. ▌
    Visual Regression · ahtishamshahzad
    Use to decide whether visual regression testing is warranted and, if so, plan it — baseline snapshots of key screens/components, deterministic rendering, review-gated diffs, and scoped coverage — without turning it into a flaky, noise-generating burden.
    0 repo stars
  39. ▌
    Dashboard Permissions · ahtishamshahzad
    Use to plan admin-dashboard permissions — admin role granularity, a permission matrix per admin action, server-side enforcement, audit logging of admin actions, impersonation safeguards, and least-privilege defaults. Builds on web-authorization for the admin surface.
    0 repo stars
  40. ▌
    Vite React Foundation · ahtishamshahzad
    Use to plan a Vite + React SPA foundation after Vite is chosen — TypeScript, project structure, client router selection, env handling (VITE_ exposure, no secrets), build/preview, linting, and SPA host fallback. Plans only; scaffolds and installs nothing without approval.
    0 repo stars
  41. ▌
    Web Component Testing · ahtishamshahzad
    Use to plan component tests — React Testing Library with user-event, accessible queries (getByRole first), MSW for network boundaries, testing behavior not implementation, and knowing jsdom's limits (real-browser behavior belongs to Playwright). Avoid snapshot overuse.
    0 repo stars
  42. ▌
    Backend Deployment · ahtishamshahzad
    Use to plan backend deployment — target selection, environment config/secrets, build artifact (container) discipline, migration-on-deploy ordering, zero-downtime rollout with health checks, worker/scheduler deployment, and rollback. Deploys require approval.
    0 repo stars
  43. ▌
    Backend Validation · ahtishamshahzad
    Use to plan server-side input validation — schema validation at every entry point (body, params, query, headers, files, webhooks, jobs), unknown-field stripping, and type-safe validated output. The server is authoritative; client validation is UX only.
    0 repo stars
  44. ▌
    Express Foundation · ahtishamshahzad
    Use to plan an Express API foundation after Express is approved — layered structure (routes/controllers/services/data), middleware order, config, error handler, baseline security middleware. Plans only; scaffolds nothing without task approval.
    0 repo stars
  45. ▌
    GRAPHQL API Design · ahtishamshahzad
    Use to decide whether GraphQL fits and to design a GraphQL API — schema/type design, resolvers, N+1 protection (dataloaders), pagination (connections), mutations/errors, query cost limits, and field-level authorization.
    0 repo stars
  46. ▌
    Database Security · ahtishamshahzad
    Use to plan database security — least-privilege credentials, network isolation, injection prevention (parameterized-only), encryption at rest/in transit, PII classification and minimization, tenant isolation at the data layer, and access auditing.
    0 repo stars
  47. ▌
    Prisma Relational · ahtishamshahzad
    Use to plan Prisma over PostgreSQL/MySQL — expressing the approved schema in the Prisma schema, migration workflow, client usage patterns (select scope, N+1 avoidance, transactions), and where Prisma's abstractions end (raw SQL escape hatch).
    0 repo stars
  48. ▌
    Repository Strategy · ahtishamshahzad
    Use to decide how a project's applications are organized into repositories — single repo, monorepo, or multiple repos — based on shared code, coupling, team boundaries, and release cadence. A decision, not a default; feeds monorepo-selection when a monorepo is chosen.
    0 repo stars
  49. ▌
    Staging Environment · ahtishamshahzad
    Use to plan a staging environment that meaningfully mirrors production — same artifact, production-parity config/data-shape, isolated from production data, exercising migrations and integrations before prod, and running smoke/E2E as a pre-production gate.
    0 repo stars
  50. ▌
    Mobile Camera Media · ahtishamshahzad
    Use to plan camera and media capture — permissions, capture/pick flows, image/video handling, and resizing/compression before upload. Requires native support (dev build or CLI).
    0 repo stars
  51. ▌
    Mobile Deep Linking · ahtishamshahzad
    Use to plan deep links and universal/app links — URL scheme, link config, route resolution, and handling cold vs warm starts. Coordinates with navigation and notifications.
    0 repo stars
  52. ▌
    Mobile Server State · ahtishamshahzad
    Use to plan server-state caching for mobile — RTK Query or TanStack Query — for fetching, caching, invalidation, retries, and offline behavior. Keeps server data out of client stores.
    0 repo stars
  53. ▌
    Mobile Unit Testing · ahtishamshahzad
    Use to plan unit tests for mobile logic — Jest (or Vitest where supported) for pure functions, hooks, reducers, and utilities. Test behavior, not implementation; align with the approved stack.
    0 repo stars
  54. ▌
    Mobile Vector Icons · ahtishamshahzad
    Use to plan icon usage — an icon set/library choice, sizing/color via theme, and lean bundling — avoiding shipping entire icon fonts unnecessarily.
    0 repo stars
  55. ▌
    Regression Testing · ahtishamshahzad
    Use to ensure every fixed bug and every critical behavior stays fixed — a failing-first test per bug at the lowest level that reproduces it, plus a maintained regression suite gating CI so old breakage can't silently return.
    0 repo stars
  56. ▌
    Dashboard Architecture · ahtishamshahzad
    Use to decide where an admin dashboard lives — inside the customer web app, as a route group, as a separate application, or in a separate repository — weighing user roles, deployment boundaries, security boundaries, team ownership, UI system sharing, and release cadence. Placement is a decision, not a default.
    0 repo stars
  57. ▌
    Backend Performance · ahtishamshahzad
    Use to diagnose and fix measured backend performance problems — profiling first, then N+1 and query work (with the database pack), caching with explicit invalidation, connection pooling, payload size, and event-loop health. No speculative optimization.
    0 repo stars
  58. ▌
    Email Notifications · ahtishamshahzad
    Use to plan transactional email and notification delivery — provider choice, template management, sending via background jobs, deliverability (SPF/DKIM/DMARC), bounce/complaint handling, and abuse-safe triggering.
    0 repo stars
  59. ▌
    Database Selection · ahtishamshahzad
    Use to choose the database (PostgreSQL, MySQL, MongoDB) and — separately — the data layer (Prisma, Drizzle, Mongoose, native driver). Relational is usually right for payments, orders, inventory, reporting, financial data, transactions, strong relations; MongoDB fits highly variable documents with embedded access patterns.
    0 repo stars
  60. ▌
    Drizzle Relational · ahtishamshahzad
    Use to plan Drizzle over PostgreSQL/MySQL — TypeScript table definitions expressing the approved schema, drizzle-kit migration workflow, SQL-proximate query patterns (joins, prepared statements, transactions), and type flow to the app boundary.
    0 repo stars
  61. ▌
    Deployment Selection · ahtishamshahzad
    Use to choose deployment targets per application — managed PaaS, container platform, serverless, static/edge hosting, mobile stores — based on app type, ops capacity, scaling, and cost. Evaluates rather than defaulting; a stack decision requiring approval. Does not provision infrastructure.
    0 repo stars
  62. ▌
    Production Readiness · ahtishamshahzad
    Use as the pre-launch go/no-go checklist — confirming tests/security passed, config/secrets/migrations/backups/monitoring/rollback/incident-response are all in place before a production deploy. Aggregates readiness signals; the release gate. Approval required to ship.
    0 repo stars
  63. ▌
    Turborepo Foundation · ahtishamshahzad
    Use to plan a Turborepo setup after it's chosen — task pipeline definition (dependsOn), input/output declarations for correct caching, affected-only execution, and CI integration. Plans configuration; does not scaffold apps.
    0 repo stars
  64. ▌
    Mobile Accessibility · ahtishamshahzad
    Use to plan mobile accessibility — screen-reader labels/roles, focus order, touch target sizes, contrast, and dynamic type — so the app is usable with assistive tech. Bakes accessibility into components, not bolts it on.
    0 repo stars
  65. ▌
    Mobile Authorization · ahtishamshahzad
    Use to plan authorization — role/permission gating of screens and actions, protected navigation, and server-verified access. Roles are enforced server-side; the client hides UI only as a convenience.
    0 repo stars
  66. ▌
    Mobile Design System · ahtishamshahzad
    Use to plan a mobile design system — tokens, spacing, typography scale, color palette, and reusable component primitives — before building screens. Establishes consistency; coordinates with theme, fonts, and accessibility.
    0 repo stars
  67. ▌
    Mobile Location Maps · ahtishamshahzad
    Use to plan location and maps — foreground/background location permissions, a maps provider, markers/regions, and battery-aware location usage. Requires native support (dev build or CLI).
    0 repo stars
  68. ▌
    Mobile Notifications · ahtishamshahzad
    Use to plan push/local notifications — provider (Expo push / FCM / APNs), permissions, token registration, handling foreground/background, and deep-link routing from taps. Requires native support (dev build or CLI).
    0 repo stars
  69. ▌
    Mobile Project Audit · ahtishamshahzad
    Use when a mobile app already exists, before changing it — inventory the runtime (Expo vs CLI), navigation, state, native modules, build config, and iOS/Android readiness. Read-only; grounds mobile planning in reality. Delegates deep security/performance to their skills.
    0 repo stars
  70. ▌
    Integration Testing · ahtishamshahzad
    Use to plan integration tests across module and I/O boundaries — real database, real wiring, faked externals — covering happy path, invalid input, error path, and authorization denial. For HTTP API specifics use api-integration-testing.
    0 repo stars
  71. ▌
    Test Coverage Audit · ahtishamshahzad
    Use to assess test coverage by risk, not by percentage — find untested critical paths (auth, money, data integrity, error/denial paths) and missing required cases, and recommend targeted tests. Never chase a coverage number without risk justification.
    0 repo stars
  72. ▌
    Backend Unit Testing · ahtishamshahzad
    Use to plan backend unit tests — services and pure business logic tested in isolation with focused test doubles, fast and deterministic, covering edge and failure paths. Route/database/HTTP coverage belongs to integration testing.
    0 repo stars
  73. ▌
    Database Migrations · ahtishamshahzad
    Use to plan schema-migration discipline — versioned immutable migration files, review of generated SQL, deploy-time ordering, zero-downtime expand/contract changes, rollback reality, and environment drift prevention. Data backfills are the data-migration skill.
    0 repo stars
  74. ▌
    Mobile Authentication · ahtishamshahzad
    Use to plan mobile authentication — login/signup, token/session handling, secure token storage, refresh, and logout — coordinating with secure storage, API integration, and the auth provider. Client auth is UX; the server enforces.
    0 repo stars
  75. ▌
    Mobile Error Handling · ahtishamshahzad
    Use to plan error handling — error boundaries, async/network error handling, user-facing fallback UI, and crash reporting (e.g. Sentry) — so failures degrade gracefully and are observed.
    0 repo stars
  76. ▌
    Mobile Native Modules · ahtishamshahzad
    Use to plan native module usage or authoring — evaluating existing packages/config plugins first, and planning custom native modules (iOS/Android) only when needed. Prefer Expo config plugins/dev builds before ejecting.
    0 repo stars
  77. ▌
    Mobile Secure Storage · ahtishamshahzad
    Use to plan secure on-device storage — Keychain/Keystore for tokens and sensitive data vs async storage for non-sensitive data — with clear rules on what may be persisted where. No secrets in plain storage or logs.
    0 repo stars
  78. ▌
    Dependency Security · ahtishamshahzad
    Use to assess third-party dependency risk from a security angle — known vulnerabilities, supply-chain integrity (lockfiles, pinning, provenance), typosquats/malicious packages, and CI enforcement — driving prioritized upgrades. The security lens on dependencies; dependency-audit is the general inventory.
    0 repo stars
  79. ▌
    Test Data Management · ahtishamshahzad
    Use to plan test data — factories over fixtures, per-test isolation, deterministic personas (users, roles, tenants) for authorization tests, and strict separation from production data. No real PII in tests; data is owned per test, not shared and mutated.
    0 repo stars
  80. ▌
    Backend Authorization · ahtishamshahzad
    Use to plan backend authorization — who may do what. Distinguishes authentication, role authorization, permission authorization, ownership authorization, organization/tenant scope, and object-level authorization; enforces centrally per endpoint and requires negative tests.
    0 repo stars
  81. ▌
    Backend Observability · ahtishamshahzad
    Use to plan backend observability — structured PII-safe logging with request correlation, metrics (rate/errors/duration, queues, jobs), health checks, alerting on symptoms, and tracing when the topology earns it.
    0 repo stars
  82. ▌
    Database Performance · ahtishamshahzad
    Use to diagnose and fix measured database performance problems — slow-query identification, EXPLAIN analysis, N+1 elimination, pagination of unbounded reads, connection-pool sizing, and lock-contention diagnosis. Evidence first; indexes via the indexing skill.
    0 repo stars
  83. ▌
    Environment Management · ahtishamshahzad
    Use to plan environment configuration across dev/staging/production — one immutable artifact configured by environment, validated typed env vars (fail fast at boot), no secrets in client bundles, and parity so behavior differs only by config. Secret storage itself is secrets-management.
    0 repo stars
  84. ▌
    Mobile API Integration · ahtishamshahzad
    Use to plan the HTTP transport layer — fetch vs Axios, base client, interceptors, auth headers, error mapping, and timeouts. Underpins server-state; does not itself cache.
    0 repo stars
  85. ▌
    Mobile Stack Selection · ahtishamshahzad
    Use to decide between Expo and React Native CLI for a mobile app, with justification. Evaluates Expo (Go, dev builds, EAS Build/Submit, OTA, common native packages) against React Native CLI (native ownership, custom modules, specialized SDKs, background behavior, CallKit/PushKit, BLE/NFC, existing native projects). Does not default to CLI.
    0 repo stars
  86. ▌
    Dashboard Bulk Operations · ahtishamshahzad
    Use to plan dashboard bulk operations — selection scope (page vs all-matching-filter), explicit confirmation with counts, server-side batch endpoints, per-item permission checks, progress and partial-failure reporting, idempotency, undo where feasible, and audit logging.
    0 repo stars
  87. ▌
    Backend Authentication · ahtishamshahzad
    Use to plan backend authentication (who the caller is) — credential storage (hashing), sessions vs JWT, token lifecycle/refresh/revocation, logout, and account flows (signup, password reset, OTP). Authentication is not authorization.
    0 repo stars
  88. ▌
    Backend Error Handling · ahtishamshahzad
    Use to plan backend error handling — an error taxonomy (operational vs programmer errors), one central handler, a single safe response shape, correct status mapping, and logging with correlation IDs. Internals never leak to clients.
    0 repo stars
  89. ▌
    Existing Backend Audit · ahtishamshahzad
    Use to inventory an existing backend before changing it — framework, structure, API surface, auth/authorization model, data layer, jobs, integrations, tests, security posture. Produces findings that feed planning; changes nothing.
    0 repo stars
  90. ▌
    Realtime Communication · ahtishamshahzad
    Use to decide whether realtime is needed and design it — SSE vs WebSockets vs polling, authentication on connect, room/channel authorization, reconnection with missed-event recovery, and multi-instance fan-out.
    0 repo stars
  91. ▌
    Role Permission Design · ahtishamshahzad
    Use to design the role and permission model — role set, permission granularity, role→permission mapping, storage/claims, admin surfaces, and evolution. Roles gate action classes; ownership/tenant checks remain separate.
    0 repo stars
  92. ▌
    Mobile Background Tasks · ahtishamshahzad
    Use to plan background execution — background fetch, location, audio, or task runners — within OS constraints, with battery and lifecycle awareness. Requires native support (dev build or CLI).
    0 repo stars
  93. ▌
    Mobile State Management · ahtishamshahzad
    Use to decide where each piece of state lives — local component state, form state, shared client state, server state, persisted state, or navigation state. Prevents dumping everything into Redux/Zustand. Chooses the lightest tool that fits each category.
    0 repo stars
  94. ▌
    Backend Stack Selection · ahtishamshahzad
    Use to decide between Express and NestJS (or flag another fit) for a backend API, with justification. Evaluates Express (small/medium APIs, lightweight architecture, fast delivery, limited modules) against NestJS (large modular systems, multiple developers, dependency injection, queues, WebSockets, many domains, strong conventions). No universal default.
    0 repo stars
  95. ▌
    Ownership Authorization · ahtishamshahzad
    Use to design ownership, organization/tenant-scope, and object-level authorization — the caller may touch only their own or their tenant's resources. Scope derives from the session, never from client-supplied IDs; requires cross-user and cross-tenant negative tests.
    0 repo stars
  96. ▌
    Document Schema Design · ahtishamshahzad
    Use to design MongoDB document schemas — embed vs reference decided per access pattern, document identity and shape per collection, growth-bounded arrays, duplication with consistency ownership, and schema validation despite "schemaless."
    0 repo stars
  97. ▌
    Mobile Component Testing · ahtishamshahzad
    Use to plan component tests — React Native Testing Library for rendering, interaction, and accessibility queries — testing components as users interact with them. Complements unit and E2E tests.
    0 repo stars
  98. ▌
    Authorization Security · ahtishamshahzad
    Use to review authorization for security holes — IDOR/BOLA, missing ownership/tenant checks, privilege escalation, trusting client-supplied IDs/roles, and function-level access gaps — verified with negative tests. The security-review lens; backend-authorization is the design/build skill.
    0 repo stars
  99. ▌
    API Integration Testing · ahtishamshahzad
    Use to plan backend API integration tests with Supertest — real HTTP requests through the full middleware stack against a real database, covering happy path, invalid input, error path, and the authorization-denial negative suite (cross-user, non-admin, cross-tenant, untrusted IDs).
    0 repo stars
  100. ▌
    Backend API Architecture · ahtishamshahzad
    Use to define the internal architecture of a backend API — layering (transport/controllers/services/data), domain boundaries, where cross-cutting concerns live, and how modules communicate. Framework-agnostic; foundations apply it per framework.
    0 repo stars