Topic
Engineering Playbooks
43 articles in Engineering Playbooks.
AI Codebase Handoff Checklist: 8 Steps Before Hiring
Use an eight-step audit to prepare an AI-assisted codebase for handoff and compare targeted repairs, refactoring and replacement.
AI-built prototype databases vs production requirements: avoiding a false BaaS/SQL choice
Assess prototype backends by their data model, controls and operations, rather than treating BaaS, SQL or MVC as proof of production readiness.
Android App Links: opening your website's links in your app, and what Android 15 changes
Learn how verified Android App Links connect a website to an app and what to consider before using dynamic rules.
Android runtime permissions: how a well-behaved app asks, and what to check
Plan Android permission requests in context, handle refusals gracefully and test the features that need sensitive access.
API design basics for mobile apps: methods, retries and safe failure
Review HTTP methods, retries and failure handling when designing mobile APIs that must cope with interrupted connections.
API rate limits and spending caps: protecting your backend and your bill
Set API request, resource and spending limits to reduce overload and unexpected third-party service costs.
Login and authentication basics: what OWASP's Authentication Cheat Sheet recommends
Review OWASP's guidance on passwords, authentication flows, account changes and defenses against automated login attacks.
Application logging: what to record, what never to put in logs
Choose useful application security events to log while keeping credentials, tokens and sensitive payment data out of logs.
Authorization and access control: define who may do what
Define object-level permissions, deny access by default and test that users cannot reach another user's or tenant's data.
Cloud cost control for startups: five principles from the AWS Well-Architected Framework
Use five AWS cost-optimization principles to discuss cloud ownership, measurement, spending accountability and resource use.
Content Security Policy (CSP) explained for site owners
Understand how Content Security Policy restricts browser behavior, where it helps and why it does not replace secure application code.
Cookies for site owners: what they do and the security settings that matter
Learn how cookies support sessions and which security settings matter when a site stores and sends browser state.
CORS explained: why your browser blocks API calls, and what not to do about it
Understand why browsers block some cross-origin API calls and why CORS is not a substitute for authentication or authorization.
Credential stuffing and password spraying: layered defenses for your login
Compare credential stuffing, password spraying and brute force, then plan layered login defenses and appropriate MFA controls.
Database indexes explained: a PostgreSQL guide to slow queries
Understand when a PostgreSQL index may help, why column order matters and what to check before changing a live database.
Docker container security: a checklist for small teams
Review Docker access, privileges, networking, resource limits, secrets and image controls using OWASP's container security guidance.
DOM-based XSS: when your own JavaScript runs the attack
Understand how client-side code can turn untrusted data into executable content and why safe browser APIs matter.
Sending app emails that reach Gmail: what Google's sender guidelines require
Review Gmail sender requirements for authentication, unsubscribe handling, spam rates and sending practices without assuming guaranteed inbox delivery.
Error handling without leaking details to attackers
Plan useful internal error reporting while preventing public responses from exposing stack traces, credentials or implementation details.
Letting users upload files safely: a checklist for app teams
Review file upload restrictions, validation, storage and access controls before accepting images or documents from users.
Forgot-password security: design the whole reset flow
Review reset requests, single-use links, abuse controls, session invalidation and compromised-account recovery as separate security decisions.
HTTP caching for business sites: what to cache, what never to share
Understand HTTP caching controls and distinguish reusable public responses from private content that must not be shared.
Input validation: what your app should check before it trusts a form or API request
Review expected input types, formats, sizes and server-side checks before an app trusts form fields or API requests.
Insecure deserialization: why you should not rebuild objects from untrusted data
Understand the risks of rebuilding objects from untrusted data and discuss safer formats and parsing boundaries with your team.
Adding maps to your app without a surprise bill: API key practices
Plan Google Maps key restrictions, usage monitoring and rotation while distinguishing visible client keys from secret server credentials.
Mass assignment: when a request sets fields it should not
Prevent requests from setting unintended fields by defining which properties each operation may accept and change.
Multi-factor authentication options compared: what each one protects against
Compare MFA methods, phishing resistance, recovery risks and factor-change controls using OWASP's published guidance.
Mobile app security checklist for founders
Use OWASP MASVS control areas to ask concrete questions about mobile storage, authentication, networking, code and privacy.
Mobile app security testing: what to expect and what to ask for
Compare mobile security testing approaches and agree scope, evidence, reporting and retesting before commissioning an assessment.
How to test a mobile app before launch: a practical plan
Build a mobile launch test plan covering critical flows, supported devices, test data, failure cases, accessibility and regression checks.
Node.js app security: a checklist from OWASP's guidance
Review Node.js request limits, asynchronous errors, permissions, headers and dependencies without treating runtime controls as a sandbox.
Passkeys for app teams: what the server side must get right
Review relying-party verification, user verification and account recovery considerations when implementing passkey sign-in.
Password storage explained: hashing, salts and upgrade plans
Understand password hashing, salts and peppers, choose a supported approach and plan upgrades without confusing hashing with encryption.
Reading a PostgreSQL query plan: EXPLAIN without the guesswork
Understand plan nodes, estimated cost and rows, and the execution risk of EXPLAIN ANALYZE when investigating PostgreSQL queries.
Push notifications with Firebase: notification messages vs data messages
Compare Firebase notification and data messages, their handling responsibilities and the limits to consider when designing push behavior.
REST API security: a checklist for app teams
Review REST API transport, authentication, authorization, input handling and error controls using OWASP's security guidance.
How search works in an app: full-text search, ranking and what "matching" really means
Understand PostgreSQL full-text search, query parsing and ranking without confusing text relevance with a complete matching system.
Session management basics: what happens after sign-in
Understand session IDs, browser cookie protections, server-enforced timeouts and why logout must do more than clear a screen.
SQLite vs a client-server database: choose by architecture
Compare embedded SQLite with a client-server database by data location, write concurrency and recovery needs rather than production labels.
Building a trading or exchange platform: security requirements to write down first
Discuss selected web-security requirements for trading products without mistaking them for a complete custody, settlement or regulatory checklist.
Transaction authorization: confirming a sensitive action so it cannot be tampered with
Design separate confirmation for sensitive actions with server-side checks, significant transaction details and single-use authorization.
A vulnerable dependency was found: what to do next
Triage a vulnerable dependency, assess its use and plan updates, testing and follow-up rather than assuming a passing build resolves the risk.
Cross-site scripting (XSS): how app teams prevent it
Review safe output handling, context-specific encoding and HTML sanitization to prevent untrusted content from executing in a browser.