2023
1,471 posts
2023 1,471
December 2023
- Implementing React scroll animations with Framer Motion
- UX design conferences in 2024: A complete list
- Building a React Native number pad feature from scratch
- Revenue vs. profit: What’s the difference and why does it matter?
- Advanced page transitions with Next.js and Framer Motion
- Using Figma’s Jambot AI to uplevel designs
- Using TypeScript with WebGL to render graphics on the web
- Building and deploying AI agents with E2B
- The best product management conferences in 2024
- Native CSS nesting: What you need to know
- Data table design: Best practices for better UX
- Using WebGPU to accelerate ML workloads in the browser
- Using the ScrollTimeline API for scroll-linked animations
- A guide to adding gradients with Tailwind CSS
- Building trust with an open-door policy
- The power of brand recognition
- 11 best Tailwind CSS component and template collections
- 5 Rust game engines to consider for your next project
- Using color gradients in Figma
- Comparing Next.js testing tools and strategies
- The best project management conferences in 2024
- Finding and fixing rage clicks
- Is the product owner role doomed?
- Leader Spotlight: Managing by exception, with Fatima Howes
- What is Jira?
- Understanding React’s useFormState and useFormStatus Hooks
- 5 project management methodologies
- UX list design made simple (with Figma template)
- Leader Spotlight: Sweating the details, with Herman Man
- Using strongly typed vs. statically typed code
- What is transactional leadership? Definition and characteristics
- Developing Next.js microservices with Nx
- An overview of growth models
- 4 ways to remove a background in Figma
- Leader Spotlight: Letting the customer decide, with Charles Battle
- Implementing password-based authentication in Next.js using Lucia
- A detailed look at data modeling
- Adobe won’t acquire Figma: What does this mean for users?
- Using the CSS contain property: A deep dive
- A guide to enterprise transformation
- How to test React Hooks
- Best practices for mobile search filter UX
- Leader Spotlight: The complexities of going global, with Ora Solomon
- What it means to be a compound startup
- Exploring the shift from CSS-in-JS to headless UI libraries
- Applying VRIO analysis for strategic advantage
- How to design input steppers with Figma
- Leader Spotlight: Easing into dramatic change, with Michael Lubansky
- Adding interactivity with GitHub’s Hotkey library
- The art of customer feedback analysis
- Loading spinners: Their purpose and alternatives for better UX
- Leader Spotlight: Operating with the genie effect, with Matt Trevathan
- Anchoring bias: The invisible hand behind decision-making
- Slow down, high performers! A guide to the art of co-creation
- Strapi adoption guide: Overview, examples, and alternatives
- A guide to agile marketing
- Survey design: Building better surveys and avoiding pitfalls
- Navigating the transition to a leadership role
- Visual regression testing with Argos CI
- Leader Spotlight: Leading digital transformations, with Jaxon Merril
- What is a eureka moment?
- Using CSS subgrid to design advanced layouts
- Importing Sketch designs into Figma
- Leveraging React Native JSI to enhance speed and performance
- What is the Psych framework?
- Using CSS prefers-reduced-transparency and light-dark()
- How the bandwagon effect influences consumer decisions
- Leader Spotlight: Finding your superpower, with Sandy Huang
- Building AR face masks in React Native
- Using Figma interactive components to prototype microinteractions
- What is the BCG growth share matrix?
- Leader Spotlight: Testing digital transformations, with Margaret Tuohy
- Utilizing research and development (R&D) to drive innovation
- Mastering the modulo operator in JavaScript: A complete guide
- Leader Spotlight: Building with grit with Ken Pickering
- A guide to product marketing
- Leader Spotlight: Meshing product- and sales-led cultures, with Carlos Jimenez
- Creating presentations using Figma
- A guide to crafting a compelling marketing plan (with template)
- Understanding SolidJS props: A complete guide
- Leader Spotlight: Leaning into opportunity through change, with Alan Fliegelman
- Eleventy vs. Next.js for static site generation
- A guide to loss aversion
- Building design documentation that will last the test of time
- Mastering meeting minutes
- Build a full-stack app with React and Goxygen
- Leader Spotlight: Balancing precedent with innovation, with Vanessa Davis
- Express.js adoption guide: Overview, examples, and alternatives
- 10 advanced Figma tips and tricks to improve your workflow
- Nesting web components in vanilla JavaScript
- How to grow retention by building habit loops
- Meet Galileo — your new AI-powered product analyst
- A guide to deciphering the competitive landscape
- Leader Spotlight: The balance between assertive and kind leadership, with Josh Schoonmaker
- A guide to real user monitoring (RUM)
- A guide to recognizing and managing unconscious bias
- Using defer in Angular 17 to implement lazy loading
- Leader Spotlight: Forging human connection on remote teams, with Michelle Monaco
- Moving from a feature-driven to an outcome-driven roadmap
- Leader Spotlight: Breaking out of silos, with MQ Qureshi
- Using ElectricSQL to build a local-first application
November 2023
- Using Rust and Leptos to build beautiful, declarative UIs
- Onboarding UX: Creating a B2B product introduction
- 5 best JavaScript multidimensional array libraries
- Scaling the product review process
- How to build a robust knowledge base
- Leader Spotlight: Dancing in customers’ shoes, with Natalie Adams Barnes
- Leader Spotlight: Leading by experience with Dom Scandinaro
- The MERN stack: A practical tutorial
- Vite adoption guide: Overview, examples, and alternatives
- 10 UX writing samples for every use case
- An advanced guide to the Web Share API and navigator.share()
- Leader Spotlight: Scaling for the next phase of growth with Chas Peacock
- Leader Spotlight: Measuring the intensity of customer problems, with Subhayu Ghosh
- Understanding the waterfall methodology
- Cypress adoption guide: Overview, examples, and alternatives
- A guide to authentic leadership
- Leader Spotlight: Strong opinions, loosely held, with Ajoy Krishnamoorthy
- Scoping CSS inline styles with css-scope-inline
- How to use the keyof operator in TypeScript
- Principles for effective icon design
- Why it’s necessary to shut down product features
- 8 tips to reduce unused JavaScript
- Leader Spotlight: The art of ruthless prioritization, with Justin Kim
- Transitioning from single product management to portfolio management
- Getting started with Bun and React
- An overview of firmographic data
- Neubrutalism in web design
- What is Little’s Law? Overview with formula and examples
- Guide to mobile emulator testing with MiniSim
- A guide to dynamic pricing
- 17 Figma design systems you need to know about
- Creating and managing styles in Figma
- Implementing safe, dynamic localization in TypeScript apps
- Why YouTube created Shorts to compete with TikTok
- A house divided: Lessons amid OpenAI’s chaos
- Leader Spotlight: Matching talent to problems, with Kristin Dorsett
- A guide to conducting market research
- Using dev containers with VS Code for an easier dev setup
- Understanding the 3 types of jobs to be done
- Creating Figma prototypes with interactions and animations
- 15 useful Figma shortcuts to speed up your workflow
- Organizing Figma files for team collaboration
- Building a progressive web app in Remix with Remix PWA
- Leader Spotlight: Right-sizing processes, with Roman Gun
- Leader Spotlight: Helping users get to ‘what’s next’ with Annyce Davis
- Embracing continuous product design
- Leader Spotlight: Investing in R&D, with Anjali Gurnani
- Astro adoption guide: Overview, examples, and alternatives
- Designing mobile breadcrumbs for smaller screens
- What is a niche?
- Using Alma to create generative graphics
- Bun adoption guide: Overview, examples, and alternatives
- A guide to creating a stakeholder matrix
- Leader Spotlight: Gathering feedback from the field, with Gayathri Somanath
- Typographic scaling: Definition, Figma tutorial, and examples
- Exploring Rust compiler options: GCC vs. LLVM
- How mission statements guide companies
- How to use CSS anchor positioning
- A comprehensive guide to drafting proposal outlines
- Leader Spotlight: Learning outside your walls, with Fielder Hiss
- Empty state UX: Designing for possibility
- Exploring Angular’s evolution: Why it’s worth another look
- Leader Spotlight: Finding product-market fit during the invention stage, with Umesh Unnikrishnan
- A guide to setting up a project management office (PMO)
- Exploring AI speech-to-text services with Python
- Using the Figma grid features to design a responsive layout
- How to calculate the payback period
- Leader Spotlight: Focusing on innovation catalysts, with Puneet Tangri
- Connected work: Navigating the chaos of collaboration
- Async rendering in React: Suspense, Hooks, and other methods
- Using the Slice tool in Figma
- Using Dioxus with Rust to build performant single-page apps
- Using team building questions to enhance collaboration
- Exploring the CSS :dir pseudo-class: A deep dive
- Understanding HTML landmarks and how to apply them
- Responsive design in Figma: Step-by-step tutorial
- How to use the Now, Next, Later roadmap
- Exploring the best online Node.js compilers
- Leader Spotlight: Charting the future of marketplaces, with Paul Ghio
- A guide to competitive analysis with template
- Leader Spotlight: Building for user engagement in edtech with Kirk Gray
- WeWork filed for bankruptcy. Where did the product go wrong?
- How to prevent overflow scrolling in CSS
- A comprehensive guide to PEST analysis
- Using CSS content-visibility to boost your rendering performance
- Leader Spotlight: Building products that fit like paper on a wall, with Konstantinos Koudigkelis
- Understanding the value of new user acquisition vs. retention
- Developing an effective CI/CD pipeline for frontend apps
- Understanding Figma’s outline mode
- How to write an effective hypothesis
- Leader Spotlight: Cultivating soft skills, with Brian Tajo
- A guide to using a value proposition canvas
- Understanding React Native encryption libraries
- A guide to understanding the shift left approach
- Extending VS Code with Continue to leverage ChatGPT
- Leader Spotlight: Exceeding customer expectations with Sai Vishnubhatla
- Why is the Mint app shutting down?
- Flat design and its relevance in today’s world
- Optimizing HTML to PDF in Node.js
- Leader Spotlight: Navigating transformation with Roger Wigenstam
- Introducing Nue JS, a Svelte alternative
- Using the React Testing Library debug method
- Using text-to-wireframe generators for quick design iteration
- An overview of product mix
- Best text editors for React
- SolidJS adoption guide: Overview, examples, and alternatives
- Leader Spotlight: Standing behind what you say, with Adam Nicholson
- A guide to leading vs. lagging indicators
- Improving mobile UX with react-native-inappbrowser-reborn
- A guide to setting project timelines
- What is the Product Operating Model?
- Understanding Astro integrations and the hooks lifecycle
October 2023
- Using Crystalize.js with React for dynamic state management
- How to tie product changes to real business impact
- Guide to load testing in Node.js with Artillery
- Implementing serverless architecture in React Native apps
- Leader Spotlight: Enriching insights through conversation, with Andy Chen
- An overview of the PMBOK Guide
- Principles and strategies for equitable design
- Storybook adoption guide: Overview, examples, and alternatives
- Different types of market research surveys (with templates)
- Leader Spotlight: Connecting the corners of the world, with Gabrielle Charnoff
- Using the useUpdates Hook to manage React Native app updates
- 16 incredible Figma templates you might not know about
- 17 common Node.js errors and how to solve them
- Leader Spotlight: A win-win approach to product management, with Cody Smith
- 5 best popover libraries for React
- 8 engaging team-building activities
- Design feedback: How to give and receive productive feedback
- Choosing the best JavaScript sorting algorithm for your project
- A guide to the software bill of materials
- Leader Spotlight: A game of balance, with Paw Larsen
- Natively implement dynamic imports in React Native
- The history of international typographic style — is it timeless?
- Creating contrast themes with CSS prefers-contrast and JavaScript
- A guide to different types of marketing strategies
- Leader Spotlight: Crafting magical messages, with Cy Khormaee
- How a workback schedule can optimize your project planning
- How CSS @scope can replace BEM
- A complete guide to React refs
- Using TanStack Query with Next.js
- Leader Spotlight: Recentering around the voice of the customer, with Erin Wright
- Using React Styleguidist to collaborate on component design
- How to write standard operating procedures (SOPs) with template
- Why you should migrate to Rspack from webpack
- Is more headcount necessary? How and when to scale a team
- A guide to continuous stakeholder interviews
- Using shiny.react to build dynamic styles
- Leader Spotlight: Optimizing speed to impact, with Sumeet Ahuja
- 4 cognitive biases that impact product adoption (with examples)
- 19 social proof examples for designers
- Exporting Figma designs to React Native: A developer’s guide
- Using LangSmith to test LLMs and AI applications
- Leader Spotlight: Predicting the future, with Drew Lesicko
- The impact of Parkinson’s Law on product development
- 34 Figma plugins to save you time at work
- Using react-native-cameraroll to enable camera roll access
- The myth of shared team ownership
- Making sense of product service management
- An introduction to the Web Preferences API
- Leader Spotlight: Building a product-led GTM machine, with Harsh Jawharkar
- Nesting Figma components: Everything you need to know
- Rust vs. Haskell: A performance comparison
- Leader Spotlight: Shaping customers’ habits, with Abhijit Chaudhary
- Build a real-time, collaborative code editor with PartyKit
- User story examples with templates
- Brainstorming UI concepts with AI
- Adding screen capture functionality to a React Native app
- Mastering self-management: Skills, strategies, and benefits
- Decision tree templates for making confident product choices
- Using the View Transitions API with Astro
- How to use TypeScript with React: A tutorial with examples
- Transferring Figma files to After Effects
- Understanding escalation of commitment in product decisions
- The matrix organizational structure: Pros, cons, and insights
- How to turn product analytics into actionable insights
- Designing your pricing page with data-driven decisions
- Harnessing the power of social proof
- How to integrate Google Maps into a Vue 3 application
- Exploring Vue.js design patterns: From basic to advanced
- How to craft an effective business continuity plan
- Leader Spotlight: Driving growth when the market isn’t growing, with Mykola Konrad
- The starter guide to using behavioral design
- Considering both customer and business value in product decisions
- Building SvelteKit forms with Superforms
- Optimizing static pages in your Next.js apps with Prisma
- Tools and strategies for leveraging digital analytics
- Leader Spotlight: Bringing product out from behind the curtain, with Mike Ohanian
- 12 UX books to expand your skillset in 2023
- The pros and cons of A/B testing
- Add interactive code snippets to statically generated sites
- Using case studies as a catalyst for product adoption
- Validating structural data with Valibot
- Leader Spotlight: Flattening the learning curve, with Karla Fiske
- Master UI design: Enhance aesthetics with the 60-30-10 rule
- What is team velocity and how to calculate it
- 5 automatic verification tools for Rust and when to use each
- Getting started with Postgres in your React app
- Automate repetitive tasks with Next.js cron jobs
- Converting Figma files to WordPress
- Balancing speed with precision in startup companies
- Creating type-safe custom client SDKs using TypeAPI
- A guide to product design
- Balancing velocity and long-term planning
- Speculative design: Powering product direction with imagination
- How to improve lead time
- Demystifying React Native Redash and Gesture Handler
- Build an AI chatbot with FastChat and JavaScript
- Advanced Electron.js architecture
- How to align product strategy with financial goals
- How to use heatmaps to improve UX
- Build a dynamic currency converter for an ecommerce React app
- A guide to product qualified leads (PQLs)
- Leader Spotlight: Climbing the magic mountain, with Sarah Owen
- The 7 best plugins to use in your Tailwind project
- A guide to understanding the order of magnitude
- Using gonew to streamline Go application development
- How props are passed to components in React
- A look at React hydration and pre-rendered HTML
- Empowering PMs: Building trust and autonomy
- Crafting a strategic UX roadmap: Key components and best practices
- An overview of product distribution channels
- The elements of responsive typography
- A guide to Remotion Studio
- Embracing big-picture themes for focused product development
- Getting started with MUI and Next.js
- Creating and styling Figma tables
- The 12 Week Year approach to productivity and planning
- Leveraging Cody AI for better and more efficient code
September 2023
- 15 solutions to common UX problems
- Getting started with LangChainJS
- Driving growth through referral programs
- Laravel Octane vs. Node.js: Performance and features
- Best headless UI libraries in React Native
- Mastering user guidance with directional cues
- Using react-arborist to create tree components for React
- A guide to becoming an effective communicator
- Leader Spotlight: Getting stuff done with Rich Lau
- Driving success through process improvement
- Turning errors into opportunities: Designing 404 pages
- How to effectively communicate with sales teams
- Introducing Valibot: A lightweight Zod alternative
- Using the Driver.js library to guide user focus
- Leader Spotlight: A little more conversation, with Nicole Keith
- Designing a seamless checkout flow: Definition, best practices, case studies
- A guide to the Van Westendorp Price Sensitivity Meter (PSM)?
- Create a CSS sprite generator tool
- Building products in the open
- 7 common Next.js HMR issues and how to address them
- How to become a subject matter expert
- One-tailed vs. two-tailed tests in UX: When to use each
- Optimizing style recalculation speed with CSS only
- Exploring Zedux and how it compares to Redux
- A guide to using SIPOC
- Mastering ideation sessions for innovative solutions
- What is resource management?
- Optimizing build performance in Next.js
- Using react-native-mmkv to improve app performance
- The power of granting teams autonomy
- Understanding the cost of revenue
- Balancing desirability, feasibility, and viability in UX
- An overview of micromanagement
- Building a reactive web app in Go with Fir
- Working with Astro’s middleware
- Leader Spotlight: Turning uncertainty into opportunity, with Jake Gutting
- Leader Spotlight: Assembling your PLG army, with Partho Ghosh
- The Fogg Behavior Model: Definition, use cases, case study
- An overview of agile project management
- Building Nx monorepos with Remix
- Bootstrap a React app with smol developer
- A guide to understanding configuration management
- Improving React app SEO with structured data
- Understanding your users with psychographics
- Optimizing Vue.js apps with web workers
- Extending object-like types with interfaces in TypeScript
- How to optimize push notifications without annoying users
- Implementing SSR in Next.js: Dynamic routing and prefetching
- Leader Spotlight: Building a culture of over-communication, with Nidhi Bhatnagar
- Managing design debt: Strategies for sustainable user experience
- Exploring Astro and Svelte vs. SvelteKit: A comparative guide
- A guide to control charts
- Passwordless authentication options with Firebase and React
- Writing problem statements in UX: Definition, example, template
- Using Blitz with Next.js to build a full-stack app
- What is the Start, Stop, Continue retrospective?
- Typical vs. Protobuf: Data serialization in TypeScript
- Working with the Next.js 13 App Router
- How to choose the optimal sprint length
- Unveiling the best design systems: Principles, examples, and key takeaways
- A guide to creating an effective strategic plan
- Comparing the Popover API and the <dialog> element
- Leader Spotlight: Promoting a culture of innovation, with Ryan Johnson
- Comparing classless CSS frameworks
- Leader Spotlight: Prioritizing customer discovery, with Susan Stavitzski
- How to use AI for faster prototyping
- Understanding 6 9s: The gold standard of system availability
- Working with CSV files with react-papaparse
- Writing Rust bindings for Node.js with Neon
- Maximizing productivity with timeboxing
- A guide to CSM certifications
- 12 best UX design courses
- Implement React Native in-app purchases for Android apps
- Managing sales requests that don’t align with product strategy
- Using OpenNext to deploy a Next.js app to AWS Lambda
- Leader Spotlight: Chasing blue ocean strategy, with Shibu Mathew
- Cultivating a customer-first culture in product development
- Implementing function overloading in TypeScript
- A guide to crafting a compelling value proposition
- Adding comment functionality to your React Native app
- Heuristic evaluation: Definition, case study, template
- Using Supabase’s vector database with PostgreSQL
- Data fetching in Next.js with getServerSideProps and getStaticProps
- A guide to conducting a needs assessment
- Common TypeScript module problems and how to solve them
- CSS lobotomized owl selector: A modern guide
- A guide to transformational leadership
- How to stay focused on business value
- Label UX: Definition, best practices, examples
- The Johari window: Improved communication and awareness
- How to send emails in Node.js using email APIs
- Improving responsive data table UX with CSS
- What is secondment and how can it help your career?
- Comparing schema validation libraries: Zod vs. Yup
- How correctly casing letters enhances visual hierarchy and UX
- Kanel tutorial: Generating TypeScript types from PostgreSQL
- A guide to improving the customer experience
- Next.js vs. Gatsby: Comparing React frameworks
- The role of the product manager in a scaling company
- The best React Native animation libraries
- What is business process management?
- Leveraging Fern to define and document REST APIs
- How to choose the best IDE for React Native
- Implementing SSO for login flows
- How to understand and address customer pain points
- Exploring the Node.js native test runner
- Comparing the top zero-runtime CSS-in-JS libraries
August 2023
- A comprehensive guide to data-driven product management
- CAPTCHA UX: Why CAPTCHA is bad and its alternatives
- Using Ink UI with React to build interactive, custom CLIs
- Overcoming the curse of knowledge
- What is app store optimization (ASO)?
- What is a one-pager? Examples, rules, template
- Recognition vs. recall: Leveraging cognitive processes in user interfaces
- Resource management in TypeScript with the using keyword
- Why agile processes won’t save you without a coherent strategy
- Best React Native in-app subscription libraries
- Sending emails in Node.js using Nodemailer
- Add refresh functionality to your React Native apps
- Case study: How we reduced cycle time by 66 percent in 6 weeks
- Understanding how React handles input state: A deep dive
- Using product strategy to help structure your organization
- End-to-end type safety with Next.js, Prisma, and GraphQL
- How to use variables in Figma
- When to use OKRs and when not to
- Using Kani to write and validate Rust code with ChatGPT
- An overview of feature flags
- Product management conferences in 2023: A complete list (updated)
- Animate React components using AutoAnimate
- Unlocking the power of embedded analytics
- Build an Electron app with electron-vite
- Making informed decisions with cost-benefit analysis
- Creative text flows using CSS shapes
- What is disciplined agile delivery (DAD)? Overview with examples
- The goal gradient effect: Boosting user engagement
- How to write an effective progress report
- A better approach to sprint reviews
- Handling the React Native ViewPropTypes error
- Building a resizable React component using custom React Hooks
- Product ops: The silent killer slowing down your product teams
- 10 of the best design systems to gain inspiration from
- A guide to regression analysis
- How to avoid CSS ch layout shifts
- Product partners and creating a minimum viable ecosystem
- 3 types of product virality
- Using Rust GATs to improve code and application performance
- Understanding async context and the future of server-side JavaScript
- 4 simple but effective ways to use affinity mapping
- What’s the peak-end rule? How to use it to improve UX
- 6 types of product-led models
- Creating type-safe styles with Panda CSS
- How to balance customer focus with innovation
- Using Hooks with React Router
- Build custom scrolling modals in React Native with Modalize
- A guide to growth hacking
- 32 universal icons for a cross-culturally clear UI
- Build a fast, Next.js-like app with Bun
- What is a balanced scorecard? Examples and template
- From rides to riches: How Uber masters the product profit game
- 7 common Next.js errors and how to solve them
- Understanding synergy: The power of combined efforts
- 7 pitfalls of user data research
- Building Next.js apps with Materio
- Navigating conflicting methodologies in product management
- How to implement a vector database for AI
- The importance of team topology
- Using ultrafetch to boost node-fetch behavior
- Best sign-up page examples from prominent companies
- What is market analysis? Definition, examples, and template
- Getting started with the Zig programming language
- Product management for internal products
- How to create a perfect design hypothesis
- What is Extreme Programming (XP) as an agile methodology?
- A guide to product strategy
- A guide to setting effective short-term goals
- Comparing the Vue 3 Options API and Composition API
- The best side projects for product managers
- React Server Components in Next.js 13
- How to create a product packaging strategy in 5 steps
- OKLCH in CSS: Consistent, accessible color palettes
- Running React and Express with concurrently
- A guide to brand extension strategies
- Guide to unit testing in React Native
- How to reposition a failing product
- Avoiding banner blindness: Designing for attention in UX
- Integrating customer support into your product strategy
- Best Feather-inspired animated icon libraries for React
- What is conjoint analysis for market research?
- How to use the System Usability Scale in modern UX
- What is annual recurring revenue (ARR)? Definition and how to calculate
- Using react-native-ble-manager in a mobile application
- Aspect ratios in UX design: Tips, guide, and case study
- A guide to scrum master interview questions
- How to use Krustlet for your Rust projects
- How to detect low-hanging fruit in business
- Building a React Native theme switcher app
- Understanding heatmaps: A guide to data visualization
- What is a reverse trial? Benefits and risks
- What is a unique selling proposition and how to craft one
- Using Hocus to run faster development environments
- What is a digital experience platform (DXP)?
- How to nail a UX design interview
- 3 types of outcomes (and how to achieve them)
- What is CSAT? A guide to measuring customer satisfaction
- How to build a GraphQL API with NestJS
- Migrating Ruby projects to Go
- What is an edge case? Meaning, examples in software development
- Using Figma’s Sections feature for better organization
- Best React Native search libraries
- What are the 5 scrum values?
- Leader Spotlight: Quantifying the impact of product marketing, with Arun Lal
- How to avoid death by PowerPoint with engaging presentations
- Using the Kaizen methodology for continuous improvement
- Applying gestalt principles in UX design
- Integrating GraphQL subscriptions in an Angular app
- Using Niko-Niko to enhance team happiness
- A guide to the 4 new Array.prototype methods in JavaScript
- Essential qualities of a successful leader
- How to avoid burnout in your PM role
- Integrating Supabase with Cloudflare Workers
- Landing page patterns for success in any industry
- Mastering facilitation: Definition and examples
- The power of a call to action (CTA): What it is and how to do it
- Writing composable CSS components for React
July 2023
- Comparing the best TypeScript IDEs
- How to run a UX writing review with non-writers
- The modern guide to React state patterns
- Effective time management: Definition, skills, and techniques
- Best certificates to boost your UX design career
- Visual design strategy in UX: Principles, tutorial, template
- How to conduct an effective design retrospective
- Better decision-making with the ladder of inference
- An introduction to WebGPT
- Top 3 services to deploy a Vue app for free
- A guide to bug management
- Five-second testing in UX: Guide, tips, template
- Building a serverless app with TypeScript
- 10 essential project management skills to add to your resume
- The UX of form validation: Inline or after submission?
- Opportunity solution trees: A list of anti-patterns to avoid
- Remix flat routes: An evolution in routing
- Is product-market fit a myth?
- Guide to stakeholder mapping (with templates and examples)
- 6 best package managers for Windows and beyond
- Best heatmap libraries for React (with demos)
- How to use ChatGPT for your product management job search
- Scope of work: Template, examples, and best practices
- UX vs. UI designers: What’s the difference?
- A guide to trunk-based development
- Animating SolidJS apps with Motion One
- Building a culture of experimentation
- Best code editor components for React
- Comparing React Native UI libraries
- How to use a Kanban to smoothly manage your discovery process
- How to undo a component in Figma
- Comparing Elixir with Rust and Go
- How to apply the iterative process
- What is Lean Six Sigma? Certifications, belts, principles, examples
- Optimizing CI/CD pipelines in your Rust projects
- Building a menu bar application with Electron and React
- Using react-intersection-observer to create a dynamic header
- A guide to observability
- Application performance monitoring (APM): Tools, metrics, and examples
- Using persuasive design responsibly
- How to write a compelling project proposal (with template)
- Getting started with Pico CSS
- A guide to reducing customer churn
- Build an efficient app with Qwik React
- Creating multiple entry points in Create React App without ejecting
- The complete guide to React Native for Web
- 4 steps for management by objectives (MBO)
- .NET MAUI guide: Complete overview + demo
- AWS Amplify and React Native: A tutorial with examples
- Overcoming analysis paralysis through effective decision-making
- The OODA loop decision making model: Meaning, process, examples
- Using Sveltris to build interoperable React and Svelte apps
- Tailwind CSS: Using dynamic breakpoints and container queries
- What is market segmentation? Definition, 5 types, and examples
- Common UX dark patterns to avoid
- Why is continuous optimization essential for product success?
- 5 team dysfunctions that hinder performance
- Leader Spotlight: Creating hybrid methodologies, with Ying Chen
- Dealing with links in Next.js
- Using Wireit to improve script efficiency and intelligence
- Understanding and maximizing average order value (AOV)
- What is multivariate testing and when should we use it?
- How to use Tailwind CSS with Svelte
- Create responsive masonry layouts for your React app
- The Tuckman model: 5 stages of team development
- Vue 3 for React developers: Side-by-side comparison with demos
- I studied 5 popular dashboard UIs — here’s what works
- What’s a design sprint and how to conduct one
- How to build trust in marketplaces
- How to use magic links for better UX
- How to focus on outcomes in your product organization
- Add firework and particle effects to your React app
- A guide to type 1 errors: Examples and best practices
- How to wrap, extend, or proxy a Vue component
- Comparing the top React Hooks libraries of 2023
- Using React in web games
- 9 free project management templates (for Excel and Google Sheets)
- Responsive UX design guide: From mobile to desktop
- Using Protobuf with TypeScript for data serialization
- How to reap the benefits of chaos engineering
- Checkmate: How we built a new product in just 6 weeks
- Fluid vs. responsive typography with CSS clamp
- What is containerization? Overview, definition, benefits, and tools
- Session replay in UX: Definition, use cases, benefits
- What is the HEART framework: Template and guide
- Exploring the Web Audio and Web MIDI APIs with virtual pianos
- What is adaptive leadership? Key principles and benefits
- 7 companies with successful product organization strategies
- Figma groups vs. frames vs. sections: When to use each
- A guide to running management meetings
- How to identify and analyze market opportunities
- React useLayoutEffect vs. useEffect Hooks with examples
- Best React Native splash screen libraries
- BHAG: How to create big, hairy, audacious goals (with examples)
- Organizing and categorizing content in information architecture
- Time to market: Definition and strategies to speed up TTM
- Designing pixel art using CSS only
- An introduction to site reliability engineering (SRE)
- How to simplify form styles using CSS accent-color
- Airbnb ‘eliminated’ the traditional PM role. Now what?
- Focusing on experience design for a memorable UX
- A guide to successful meeting management
- UX design socialization process: How do we design for success?
- Comparing the best Node.js schedulers
- How to decide when to charge customers
- Inheritance vs. composition in Vue
- A complete guide to the Node.js event loop
- A guide to network diagrams
- tRPC vs. GraphQL: Which is better for your projects?
- Babel vs. TypeScript: Choosing the right compiler for your project
- Configuring Apache for Node.js
- How to improve team morale in uncertain times
- Extending React with Astro and Cloud Functions
- A guide to PRINCE2: Principles, themes, and processes
- Conversion funnel mapping: Uncovering insights about your users’ behavior
- Using Replit with Node.js to build and deploy apps
- Comparing the best CSS grid generators
- Can Threads overtake Twitter? First impressions of Twitter’s new competitor
- Node.js server-side authentication: Tokens vs. JWT
- What is issue management and how to implement it
- The biggest Next.js boilerplates of 2023
- Best practices for designing ethical AI user interfaces
- How to use the tiger team approach
- Understanding value metrics to set your pricing strategy
- Improving Node.js performance using Rust
- Generating JSON Schema from TypeScript types
- How to write acceptance criteria: Definition, formats, examples
- Build a full-stack CRUD app with SolidJS
- Who’s a T-shaped UX designer and how can you become one?
- Best headless CMS platforms for Astro
- A guide to digital experience monitoring (DEM)
- Behavior-driven development principles and practices
- Defining your pricing model using max-diff surveys
- 6 deployment libraries for Rust
- What is a digital transformation strategy?
- Implement a WebAssembly WebGL viewer using Rust
- A UX designer’s guide to opportunity solution trees
- What is user engagement and how to improve it
- The top CSS libraries to empower your web design
- A guide to monetization models
- Vue.js conditional rendering: v-if vs. v-show
- Implementing data parallelism with Rayon Rust
June 2023
- Localizing content with Remix and Contentful
- Using Hick’s Law to help users make decisions
- Is product management going away? Why Airbnb got rid of its PMs
- How to build a React Native customer feedback app
- Type II error: What it is, how it works, and how to prevent it
- What is a business model canvas? Overview with template
- Guide to rotating text in CSS
- Understanding new vs. recurring revenue for better forecasting
- A guide to DORA metrics
- Building a shopping cart app with Vercel Stack
- Top 20 product management courses: Free, paid, online, and in-person
- How to monetize new features and use cases
- 5 lessons from Bing’s product strategy in the battle against Google
- Building a Rust app with Perseus
- What is time to value? Guide and how to calculate
- Understanding flatMap() and other TypeScript arrays
- Decision-making support with the Cynefin framework
- The iterative process: Definition, steps, and overview for agile teams
- Comparing the best React timeline libraries
- Exploring Node.js v20 features in action
- What is an action plan? Steps, template, and examples
- Product information management (PIM) systems and best practices
- What is product operations (aka product ops)? Benefits, responsibilities
- Declaring JSX types in TypeScript 5.1
- Unleashing the power of site reliability engineering (SRE)
- The 10 best CSS background generators for 2023
- How Turbowatch compares to Nodemon
- Drawbacks of using AI tools in product management
- React Hooks vs. Redux: Do Hooks and Context replace Redux?
- User interview questions library: 23 example questions
- What is user acquisition? 9 strategies for mobile apps and digital products
- How to authenticate React applications with Supabase Auth
- Understanding the new Firebase AI extensions
- A guide to user flow diagrams
- How to debug TypeScript in Chrome
- Scaled Agile Framework (SAFe): Principles, levels, certifications
- Build an object classification app with TensorFlow.js and React Native
- Jakob’s Law: Creating familiar and user-centric interfaces
- The role of quality assistance in an organization
- What is a sprint retrospective in agile?
- Leader Spotlight: Creative problem solving, with Monika Portman
- What is a project sponsor? Definition and examples
- What is MTTR? Examples and guide to system performance
- Customized drag-and-drop file uploading with Vue
- How to create a custom toast component with React
- CSS trig functions: Practical applications
- 5 best design handoff tools for simple design-to-code
- How to use JavaScript’s BigInt
- Type 1 vs. type 2 decisions: The art of decision-making in business
- Using setTimeout() and other timer APIs in Node.js
- Filtering TypeScript value types
- What is a single source of truth?
- Remix and Supabase: Build a real-time chat app
- How to find and recruit UX research participants
- 5 ways to implement a striped background with CSS only
- How to build trust through leading by example
- What is servant leadership? 10 principles, characteristics, and examples
- Getting started with the Mojo programming language for AI
- 8 tactics to improve the free trial experience
- How to use Miro for creating UX sitemaps
- Understanding TypeScript generators
- What is the theory of constraints? Complete guide with examples
- A guide to native routing in Expo for React Native
- How to organize your Rust tests
- How to communicate clearly using the SCR framework
- Build a job hosting site using Appwrite and Next.js
- How to create a web app in Rust with Rocket and Diesel
- What is brand loyalty and why does it matter?
- Testing browser support of CSS features with feature queries
- Building a REST API with Firebase Cloud Functions, TypeScript, and Firestore
- Creating proof: How to balance gut feeling with empirical evidence
- How to craft a visual aesthetic the right way
- Value stream mapping: Examples, process, template, and symbols
- Exploring HyperSwitch, a payment switch built on Rust
- Product sense: Harnessing your natural power as a PM
- How to authenticate Phoenix with Guardian
- Using event bus in Vue.js to pass data between components
- A guide to using ts-reset for TypeScript
- Understanding group dynamics: Definition, theory, and examples
- Measuring ease of use in UX
- Design vs. accessibility and the CSS visually-hidden class
- 4 types of product assumptions and how to test them
- Exploring use cases for TypeScript tuples
- Build a React Native drawing app with PencilKit
- What are customer analytics and how to understand them
- React Native end-to-end testing with Detox
- Exploring TypeScript 5 features: Smaller, simpler, faster
- What is the B2B2C model? Meaning, companies, and examples
- Analytics for UX designers: How to track user metrics
- Product management: A definitive guide
- Building a full-stack app with Remix and Prisma
- Implementing organizational change with the ADKAR model
- Leader Spotlight: Promoting diversity in UI/UX, with Juan Carlos Pontaza
- What is a product differentiation strategy? Guide with examples
- Gamification in UX: Increasing engagement through games
- Build better products with subject matter experts
- How to use GraphQL in a Spring Boot app
- Exploring the best syntax highlighting libraries
- Building a data-driven insight generation loop
- Using styled-components in React
- react-virtualized vs. react-window
- Guide to removing unused CSS code with PurgeCSS
- What is perceived value and how can you capture it?
- What is competitive advantage? Strategy with examples
- How to implement cursor-based pagination in GraphQL
- Using Material UI with React Hook Form
- Selecting the best Vue 3 toast notification library
- Working in silos: Meaning and strategies for cross-functional collaboration
- What is an agile release train (ART)?
- Using resizeMode in React Native to scale images
- Lit vs. React: A comparison guide
- Gap analysis: Template, definition, and examples
- Leader Spotlight: Driving profitability through engineering with Danielle Cooper
- What is a decision matrix? Templates, examples, and types
- How to fetch and handle blob data in React Native
- Guide to creating responsive web layouts with CSS grid
- Using Cloudflare Workers with Remix and Superflare
- Understanding lazy loading in JavaScript
- How to create a Lean Canvas (with template)
- What is version control? Definition, types, systems and tools
- How to collaborate with a product manager as a UX designer
- The PDCA cycle in modern product management
- Integrating the WebContainer API with Node.js
- 7 best Node.js logging libraries and aggregators
- Using altitude maps to become a more data-oriented PM
- Conducting a focus group for UX research
- How to set and accomplish long-term goals (with example)
- How to build accessible components for Vue
- Product lifecycle management: An overview
- Best methods for unzipping files in Node.js
- Conducting a diary study to understand user behavior
- Understanding Conway’s law
- Best open source pagination libraries for Vue 3
- Fit gap analysis templates and best practices
- Understanding sibling combinators in CSS: A complete guide
- AI invasion: How companies are inserting AI into their products
- Styling with the CSS :empty pseudo-class
- How to give and receive constructive criticism (with examples)
- Leader Spotlight: Experience-driven culture, with Mustafa Altay
May 2023
- What is a product vision? Definition, template, and examples
- Guide to building a product roadmap (with template and examples)
- How to get candid answers with guerilla usability testing
- What is the DACI decision-making framework? Examples, template
- The iron triangle in project management: Definition, strategies, and examples
- Linting defensive and logical CSS with Stylelint plugins
- An honest guide to making mistakes as a product manager
- Creating animated logos with Lottie and Vue 3
- The art of delegation: Tips, challenges, and best practices
- How to use Figma branching properly
- Guide to Kotlin filtering for Android
- What is net revenue retention (NRR)? Formula, examples
- Beyond ChatGPT: Other AI tools for product management
- Structura.js vs. Immer.js: Comparing libraries for writing immutable states
- Customer retention rate: Meaning, formula, how to calculate
- Using built-in utility types in TypeScript
- Node.js web scraping tutorial
- How to perform a UX content inventory
- Statement of work: What it is and how to write one
- Building type-safe forms in React with react-ts-form
- 4 templates to uplevel your product strategy
- Build a full-stack TypeScript app using tRPC and React
- Communication styles: 6 types and 4 frameworks
- What is net present value (NPV)? Formula and how to calculate
- Exploring React Native pointer events
- The Ansoff matrix: Comprehensive overview with examples
- Applying negative space in web design
- Generate TypeScript and C# clients with NSwag based on an API
- Prototyping using a design system
- Building a React code editor and syntax highlighter from scratch
- A guide to cross-compilation in Rust
- A guide to successfully managing up
- Building custom React Native map markers
- Leader Spotlight: User feedback and the product roadmap with Rasmus Seeberg
- Guide to product instrumentation for product managers
- What is user acceptance testing (UAT)? Template, best practices
- Building a Tailwind CSS table component
- Writing webpack plugins in Rust using SWC for faster builds
- 6 Liberating Structures to spice up your retrospectives
- Social loafing: What it is and how teams can overcome it
- A complete guide to using IndexedDB
- Boss vs. leader: The difference and why it matters
- Building reusable React components using Tailwind CSS
- Getting started with Ecto in Phoenix
- A deep dive into React Native FlatList
- 5 user activation metrics every PM should track
- What is a proxy, and how does it work in Node.js?
- Build a full-stack serverless app with SST
- Facilitation skills, principles, and best practices
- How to debug Node.js using Chrome DevTools and watchers
- Readability in UX: What is it and why is it important?
- Mastering the omnichannel journey: Definition and strategies
- Using ArkType for TypeScript runtime validation
- What is a scrum master? Responsibilities, skills, and more
- Democratic leadership style: Definition, examples, pros and cons
- Using Notion and Next.js ISR to sync content across platforms
- Using Axios with React Native to manage API requests
- The art of saying ‘no’ as a product manager
- How to use the Storybook Framework API
- What is a service blueprint? Template and examples
- How to build interactive pie charts using only CSS and HTML
- How to create a custom Vuetify grid system
- Adding zoom, pan, and pinch to your React web apps
- Customer analytics: Using data to improve the customer experience
- React useMemo vs. useCallback : A pragmatic guide
- Using server functions with Qwik and Qwik City
- A guide to video playback in React
- What is conversion rate optimization (CRO)?
- Exploring Go mocking methods and the GoMock framework
- The best Next.js starter templates
- What is earned value management (EVM)?
- 3 ways to render large datasets in React
- 15 best CSS shape generators with demo
- What is a service-level agreement (SLA)? Definition, templates, and examples
- What are in-app purchases? Meaning and strategy
- Getting started with Vue Select
- Exploring Astro’s Content Collections API with a demo project
- Mocking in Rust: Mockall and alternatives
- What is quantitative analysis? Definition, examples, and pitfalls to avoid
- Effective prompt writing in ChatGPT
- Building a file manager in React with Snorlax
- Building reusable UI components with React Hooks
- Leader Spotlight: Cultivating relationships and fostering collaboration with Scott Burgett
- Using Figma smart animate to prototype animations
- Writing AWS Lambda middleware with Middy.js
- Behavioral segmentation: How proper segmentation can generate valuable insights
- How and why to run a scrum of scrums
- Create and manage windows in your Rust app with Winit
- 11 product management tools every PM should have in their stack
- How to design a chatbot customers will actually use
- Using Gluon to build lightweight desktop applications
- What is asynchronous communication and how to balance it
- Build a desktop app with Qt and Rust
- How to employ unmoderated usability testing
- Building microservices in Rust with Spin
- What is a mind map?
- What is rapid prototyping for product development?
- Implementing React state management with Signia
- Using TypeScript with Redux Toolkit
- Herzberg’s two-factor theory of motivation-hygiene: An overview
- Looking forward: Creating your company’s design vision for the future
- Using behavioral analytics to create a great product experience
- A guide to wrapping in CSS
- CSS gap property vs. margin property
- Guide to CSS logical properties
- What are push notifications and why are they important?
- Implementing service workers in your Next.js app
- Qualitative analysis: Harnessing data to understand your users
- Leader Spotlight: The evolution of DevEx with Vilas Veeraraghavan
- How to create a work plan (examples and template)
- TanStack Query and WebSockets: Real-time React data fetching
- How to develop an innovation culture
- How to gain a sustainable competitive advantage
- Applying constraints to Figma layouts for resizing
- What is PI planning in agile?
- Getting started with the TypeScript satisfies operator
- What is odds ratio analysis?
- Testing the React Router useNavigate Hook with React Testing Library
- Sending emails in Phoenix using Swoosh
- How to create an operating plan: Examples with template
- Better problem solving with root cause analysis (with template)
- Guide to hiding elements in CSS
- Building a React modal module with React Router
- Configuring horizontal and vertical scrolling in Figma
- How expectancy theory can motivate your team
- What is a proof of concept: Definition, examples, and template
- Optimizing Rust code with LLVM: A detailed breakdown
- Porter’s Five Forces analysis: What it is and how to do it
- Diagnosing React Native crashes
- A guide to realistic project scheduling
- What are daily active users and what is a good DAU?
- Building a SolidJS UI with Kobalte
- When to use never and unknown in TypeScript
- Correlation analysis: How to calculate in Excel (with examples)
- Designing a custom UI using React Native Paper
- Best icon libraries for Vue.js
- How to create a React admin panel
- What is digital product management? A high-level guide
- Build async-awaitable animations with Shifty
- Publishing Node modules with TypeScript and ES modules
- Risk-driven development with the spiral model
- How to build a tree grid component in React
April 2023
- Top 15 product management certification programs
- Hybrid rendering in Astro: A step-by-step guide
- Implementing first principles thinking into your team
- A guide to the customer discovery process
- Using modern decorators in TypeScript
- Using Camome to design highly customizable UIs
- LTV:CAC ratio: Definition, strategies, and how to calculate
- Best practices for discoverability in UX
- What is stakeholder analysis? Template, examples, frameworks
- Exploring the best GraphQL data visualization tools
- Building custom maps with React Native Mapbox
- What is requirements gathering? Template and examples
- What is an aha moment? Meaning, examples, and types
- What are the 3 scrum team roles?
- Why you should avoid Selenium for unit testing Node.js apps
- Accessing Vue.js properties globally with globalProperties
- Creating a headless design system using Figma
- Boost accessibility for high-contrast users with CSS
- What is the Spotify model in agile?
- Build a real-time chat app with Rust and React
- Top 5 change management certifications
- Plotting Rust projects using Plotly
- Setting up visual regression testing with React Native Owl
- What is incremental innovation and how does it work?
- How to convert Figma components to Next.js with Tailwind CSS
- Getting started with React Native and ClojureScript
- Using reactive variables with Apollo Client
- What is product cost and how to calculate (with example)
- How to build a WebSocket server with Rust
- What is a product analyst: Role, skills, and responsibilities
- B2B vs. B2C UX design: Same steps, a different approach
- A guide to RxJS Observables
- Create an async CRUD web service in Rust with warp
- Build a web editor with react-monaco-editor
- Using Next.js with TypeScript
- Authentication in Svelte using cookies
- Protecting Next.js apps from CSRF attacks
- Rough order of magnitude (ROM): Inputs, techniques, template
- Top 10 React Grid components and libraries for 2023
- What is project cost estimation? 5-step process with examples
- Setting up a monorepo with Lerna for a TypeScript project
- Using layer masks correctly in Figma
- Using Rust scoped threads to improve efficiency and safety
- Guide to business model innovation: Strategies and examples
- Getting started with Sendbird in React Native
- UX research methods: Deciding which to use for your project
- Understanding Cloudflare Workers in Rust
- How to write a user persona: Template and examples
- Business transformation guide: Strategy, process, and examples
- How to fix a NullPointerException in Android
- Identifying and addressing Kotlin code smells
- Build an application with Node.js and PouchDB
- Dynamically creating JavaScript elements with event handlers
- A guide to CSS container queries
- Introduction to Vue lifecycle hooks
- Guide to using S-curves in project management
- Using React Webcam to capture and display images
- How to write type-safe CSS Modules
- A guide to Vitest automated testing with Vue components
- What is market demand and how to find it
- A guide to Material Design with React
- Pattern matching and type safety in TypeScript
- Creating responsive mobile layouts with Pure.css
- Product charter: What’s included and how to create one (with examples)
- A designer’s guide to developer handoffs with Figma
- The emphasis principle of design: Why focal points matter
- Add stepper components to your React app
- Learn how to build a monorepo in Next.js
- Understanding the different types of survey questions
- Understanding and handling Rust mutex poisoning
- Build customized data tables with PrimeReact
- Understanding when and how to prioritize React UI updates
- How to deal with impostor syndrome as a product manager
- How to use styled-components with React Native
- React vs. Svelte: Performance, DX, and more
- What is scope creep and how to prevent it
- Understanding OpenGL basics in Rust
- How to represent large numbers in your Node.js app
- What is project governance? How to effectively oversee projects
- Build a SwiftUI customizable segmented control
- Create customizable and shareable calendars in React Native
- The top 5 lazy loading libraries for React in 2023
- 11 Figma widgets to speed up your workflow
- Exploring 5 popular React Native color picker libraries
- Building a TypeScript CLI with Node.js and Commander
- How to build keepAwake into your React Native app
- Using React Native Reanimated for seamless UI transitions
- Type HTML faster in React with Emmet and VS Code
- What is an ideal customer profile (ICP)? Template and examples
- Using BufRead for faster Rust I/O speed
- What is product adoption and how do you measure it?
- A guide to JavaScript bitwise operators
- Using design thinking steps to build great products
- Determining your company’s UX maturity stage
- Understanding API key authentication in Node.js
- Write a scalable OpenAPI specification for a Node.js API
- Product development manager: Role, responsibilities, job description
- NestJS interceptors: Guide and use cases
- How to write a problem statement: Template and examples
- What is penetration pricing? Definition and pricing strategy examples
- Kotlin multithreading: Comparing .wait() , .sleep() , and .delay()
- 8 Figma plugins for design system management
- Understanding CSS preload and other resource hints
- What is voice of the customer (VOC)?
- Glossary and key concepts for mobile product managers
- Building a prototype with Chunk
- What is churn rate? Formula, definition, and how to reduce churn
- How to implement in-memory caching in Go
- Product development strategy: Definition, examples, and guide
- A guide to natural language processing with Python using spaCy
- Translate your React app using Format.js
- Creating custom CSS typography with COLRv1 specification
- How to conduct informative after action reviews (AARs)
- The product process matrix (PPM): Definition, examples, and template
- Pre-rendering your React app with react-snap
- 5 useful JSON tools to improve your productivity
- SCSS vs. styled-components: Advantages and caveats
- Guide to UX mapping methods
- Director of product management: Job description, responsibilities
- Cause and effect analysis with a fishbone (Ishikawa) diagram
- Build a React Native app with Solito
- How Tabby compares with the VS Code terminal
- The guide to signal handling in Rust
- The MoSCoW method for prioritization: A guide for agile teams
- Understanding slots in Vue.js: Types, benefits, use cases
- Can you create beautiful stroked text in CSS?
- Firebase vs. Supabase: Choosing the right tool for your project
- User onboarding: How to create a smooth user experience
- Customize a reusable React dropdown menu component
- Exploring Lerna’s second era
- Understanding the exclamation mark in TypeScript
- Building an adaptive, accessible UI library with React Aria
- What is a steering committee? Definition, purpose, responsibilities, and template
- Design friction: Using friction for better UX
- A modern approach to market sizing
- 15 product roadmap tools to consider (free and paid)
- Promise handling for complex modals in Vue 3
- Building Vue.js grid layouts: Best libraries and components
- Create smooth page transitions with Barba.js
- What is a sprint for agile and scrum teams?
- What is project scope management? Examples and template
- What are the four functions of management?
March 2023
- Styling webpages with Sakura CSS
- What is rapid application development (RAD)?
- Get started with libSQL, a next-gen fork of SQLite
- Keeping an eye on competition: TikTok vs. Instagram case study
- Common product manager interview questions and answers
- Using task analysis to improve your UX design
- How to build a blockchain with Go
- Next.js font optimization: Adding custom and Google fonts
- How to build a real-time Vue app with WebSockets
- How to prepare for a product manager interview
- How to add dynamic styling and class names in Vue.js
- What is exploratory testing? Benefits and how it works
- Using React lifecycle methods in Clojure apps with re-frame
- Building a simple login form with Node.js
- How to price your product in 4 steps
- Dark mode in React: An in-depth guide
- Qualitative vs. quantitative research and when to use each
- Set up rate limiting in Next.js with Redis
- Netlify vs. Cloudflare Pages
- Simplify your codebase with Swift’s decorator design pattern
- What is click-through rate (CTR)? Formula and how to calculate
- Getting started with Create React App
- Creating enterprise personas for B2B UX
- Using go generate to reduce boilerplate code
- How to create better themes with CSS variables
- Research and development (R&D) and the product lifecycle
- Visualizing GraphQL query data with Neo4j
- What is ARPPU? Definition, formula, and how to calculate
- Efficiently manage large files in Git with Git LFS
- What is a work breakdown structure (WBS)? Template, examples
- Exploring data visualization with Unovis
- Simple root cause analysis using the Five Whys framework
- Converting videos to GIFs using FFMPEG on Android
- A guide to product metrics and KPIs
- A guide to continuous interviewing
- How to transform product culture with paper prototyping
- How to write reusable components in Phoenix LiveView
- Testing React components: react-testing-library vs. Enzyme
- Build complex SPAs quickly with vue-element-admin
- Making your components dynamic in Vue 3
- A UX designer’s guide to implementing push notifications
- Can ChatGPT transform how we build products?
- How to create a go-to-market strategy: Guide with examples
- What is product architecture and how to define it
- Understanding Rust disambiguating traits: Copy , Clone , and Dynamic
- Using SuperTokens for authentication in Next.js
- What is convergent thinking and how is it used?
- How to build a ClojureScript web app with React and Reagent
- Impact effort matrix: Prioritization made simple
- Using Cow in Rust for efficient memory utilization
- Guide to fast-tracking and crashing in project management
- Storytelling: Designing the user’s journey with UX story mapping
- How to achieve business agility using agile concepts
- Create responsive sidebars with react-pro-sidebar and MUI
- The 4 best React Native routing libraries
- Exploring NestJS middleware: Benefits, use cases, and more
- Shiny object syndrome: Definition, examples, how to overcome
- Headless browser testing guide
- Options for building React Native collapsible accordions
- Rate limiting your Go application
- How to create a double border in CSS
- What is affinity grouping? Definition, examples, and how-to
- Debugging GraphQL APIs with Insomnia
- What are sprint goals? Why you need them and how to write them
- How React Hooks can replace React Router
- Top 6 tools for Node.js monitoring
- How to write an executive summary: Templates and examples
- A guide to using act with GitHub Actions
- Android CI/CD using GitHub Actions
- Next.js vs. Angular: Comparing key features and use cases
- What are product specifications? Guide, examples, and template
- Building iOS Lock Screen widgets
- Total addressable market (TAM): Definition and how to calculate
- Unit and integration testing for Node.js apps
- AI in UX design: How to leverage AI and how far it’ll get you
- What is the software development lifecycle (SDLC)? Phases and models
- What are Liberating Structures? Introduction and examples
- How and why to use attribute selectors in CSS
- The complete best practices for minifying CSS
- Writing interactive component stories with Histoire in Vue 3 and TypeScript
- How to calculate lifetime value for SaaS products
- Creating a dynamic QR code generator in Vue
- How to build an accessible design system
- What is a mockup? Definition, types, and how to create one
- Contentful and Gatsby: Build a static site with a headless CMS
- A deep dive into mutations in TanStack Query
- A guide to project planning (with template and examples)
- Top React boilerplates of 2023
- Creating CSS masonry-style layouts
- Agile transformation: Roadmap, challenges, and frameworks
- How to design and conduct a UX survey
- 10 productivity tips to be a more efficient product manager
- When not to use the useMemo React Hook
- A guide to Node.js design patterns
- Understanding guards in NestJS
- Migrating a TypeScript app from Node.js to Bun
- The complete guide to scrum artifacts
- What is monthly recurring revenue (MRR)? Meaning, formula
- Best GUI frameworks for Go
- Comparing Milkdown with other WYSIWYG editors
- What are critical success factors? Examples, definition, overview
- Using ghost buttons in UX design for effective CTAs
- How to work by working backwards (the Amazon method)
- Exploring bundling in Lightning CSS
- How UX teams can use the Jobs-to-be-Done framework
- How to build a progress bar indicator in Next.js
- What is a prototype? Definition, types, and prototyping methods
- A guide to design concepts: Mockups, wireframes, and more
- How to build a skeleton screen with CSS and React
- What is a feature owner? Responsibilities and role for agile teams
- Using Helmet in Node.js to secure your application
- Making smarter UX design decisions with the Cynefin framework
- How to create a wavy background using CSS and SVG
- Lessons learned in project management: Template and guide
- Migrating from Prettier to Rome
- Web workers, React, and TypeScript
- Web components vs. React
- A complete guide to declarative diagramming with D2
- What is a market development strategy?
- ARIA-live regions for JavaScript frameworks
- How to debug Rust with VS Code
- What is a story map? Definition, template, and examples
- Exploring Anime.js with an example site animation project
- Using React with Appwrite to set up user authentication
- How to use Tailwind CSS in React and Vue.js
- Conducting UX design critiques for helpful insights
- What is low-code/no-code app and product development?
- vh and vw: Guide to CSS viewport units
- NoSQL wide-column stores demystified
- A guide to adding SSR to an existing Vue 3 app
- What is a product owner? Role and responsibilities for scrum teams
- Building a full-stack TypeScript application with Turborepo
- Using Insta for Rust snapshot testing
- Creating smoother CSS transitions with Animate CSS Grid
- Captive product pricing: How to accessorize core products
- 3 agile frameworks you need to know (besides scrum)
- Build an accessible modal with focus-trap-react
- What is the top-down vs. bottom-up approach?
- Building a React live streaming app with 100ms
- Using Riot.js, a component-based UI library
- Using React Flow to plan a React project
- Rendering large lists with React Virtualized
- Building an intentional iterative UX design process
- Building a Next.js app using Tailwind and Storybook
- How to build continuous discovery habits on your product team
- How to align your team using a team charter (with template)
- Building a React portfolio website with Locomotive Scroll
February 2023
- Making a complex design system with Tokens Studio for Figma
- How to make an idle timer for your React app
- Economies of scale: Definition and digital applications
- Kotlin IntArray , Array , and emptyList()
- Using scrum boards to organize your sprints
- Matching elements in CSS with :nth-child and other selectors
- A guide to using Primer.css
- Value chain analysis: Why it’s important and how to do it
- How to develop charts in your Django admin with Chart.js
- A guide to CSS object-view-box
- A complete guide to CSS word-wrap , overflow-wrap , and word-break
- How to use AWS Amplify for Next.js authentication
- What is assumption mapping? Complete guide with examples
- Communicating between Node.js microservices with gRPC
- Linting in Rust with Clippy
- What is a technology stack and why the right one matters
- Build a project using Angular and NestJS
- What is a workflow management system? Software and how-to
- Standardizing emoji display across Android and iOS apps
- Using affinity diagramming for collaborating in UX design
- How missing.css compares to Tailwind CSS
- Breaking down the definition of ready in scrum
- Type checking with TypeRunner
- Using Jotai with Next.js to share state across your app
- Using CodeGeeX as a GitHub Copilot alternative
- What is first mover advantage — and is it really an advantage?
- How to write a product status report (with template and examples)
- Build a video upload and compression app with Multer and React Native
- How agile spike stories explore product uncertainties
- Getting started with fnm, a Rust-built Node.js version manager
- Building a Rust Discord bot with Shuttle and Serenity
- The new product development process: 7 stages
- Making your website scannable for better UX
- Strategy vs. tactics: What’s the difference and how to measure
- How to change an Android SDK path
- What is willingness to pay (WTP) and how to test it
- Creating a frictionless user onboarding experience
- How to write a communication plan (with template and examples)
- Build an internal error notification system in Go and Svelte
- The 4 Ds of time management: How to be more productive
- Using Android’s RecyclerView to handle complex lists
- How to create a video and audio recorder in React
- What is a design concept and how to write one?
- Guide to time blocking: How to optimize your workload
- How to build polymorphic components in Rust
- Software testing lifecycle phases: Alpha, beta, and general availability
- An intro to routing in Go with Gorilla Mux
- When and how to use CSS will-change
- How to speed up incremental builds with Gatsby’s Slice API
- Event bubbling and capturing in React
- How to define higher-order functions in Rust
- What is product discovery? Process, techniques, and templates
- Demystifying Rust’s lazy_static pattern
- What is the critical path method? Complete guide with examples
- Node.js child process: How to launch external programs
- Implement in-app notifications with NestJS, MySQL, and Firebase
- OKRs vs. KPIs: What’s the difference?
- Implementing notifications in React with Reapop
- How to initialize state using React Hooks
- The CIRCLES method: A PM’s guide to talking about design
- Making a website mockup in Figma
- How to deal with dependencies
- Optimizing performance in a React app
- Using Air with Go to implement live reload
- Build powerful React forms with Informed
- What are project milestones and how do they evolve?
- How to create a skewed highlight with CSS
- The good, bad, and ugly of product management
- Debug React apps with React Developer Tools
- React Native vs. Ionic
- Deep work slots: How to stay focused and avoid distractions
- Using the v-switch Vuetify component
- Comparing React testing libraries
- Getting started with Inertia.js, Vue.js, and AdonisJs
- What is a customer advisory board? Best practices, agenda, benefits
- Building a REST API in Rust with warp
- Using React with Popper and styled-components
- What is Kanban and why do organizations use it?
- How to use a circuit breaker in Node.js
- What is ROI: Definition, formula, examples, and how to improve it
- Managing orientation changes in React Native apps
- SvelteKit Auth with AWS Cognito
- What is user research democratization and why does it matter?
- A guide to Vuex ORM
- The difference between high-performing and ordinary teams
- Using AG Grid in React: Guide and alternatives
- How to use Android Debug Bridge for advanced troubleshooting
- Eisenhower Matrix: How to prioritize tasks (examples, template)
- Getting started with Realm for React Native
- Why product-market fit is not enough: 4-fits framework
- Integrating augmented and virtual reality into a Node.js app
- MDX integration strategies for Next.js
- Mission vs. vision statements: Key differences and importance
- Pinning Rust async data types for memory safety
- Understanding process mapping and how it works
- Building a Rust parser using Pest and PEG
- What is a product backlog in scrum? Overview for agile teams
- Comparing Rust IDEs: IntelliJ IDEA, VS Code, and more
- Building a multi-framework dashboard with Astro
- Building a carousel component in React using Hooks
- Minimize project risk using the stage-gate process
- Creating an interactive SVG: The circle of fifths
January 2023
- Build a fintech app with Plaid and React Native
- How to implement infinite scroll with Vue
- Choosing and connecting a React Native backend
- What is a burndown chart?
- Using @property for loosely typed CSS custom properties
- Top 6 frameworks for decision-making
- Using SDL2 bindings in Rust for game development
- A complete guide to threads in Node.js
- Using Pulumi with TypeScript
- Easy ways to send emails in Go
- Understanding tech basics for non-technical product managers
- Mocking GraphQL requests using the React Apollo library
- What is iterative and incremental development? Process, examples
- Go migration guide: Node.js, Python, and Rust
- How to create an effective contingency plan
- How usability testing can inform UX teams
- Understanding Docker container monitoring
- What is release management? 3-step process for agile teams
- How to understand and identify distinctive competencies
- Create a to-do list app with Phoenix, React, and TypeScript
- Comparing the most popular JavaScript charting libraries
- React Native vs. Swift for iOS development
- Using Rust with Axum for error handling
- A guide to visual hierarchy in UX design
- How to become a product manager: A 12-month plan
- Effectively using the six thinking hats in product management
- Building an Android app with GraphQL
- How to create and read QR codes in Node.js
- What is a business case and how to write one (with template)
- Incorporating machine learning into your Android app
- Why cannibalization in product doesn’t have to be bad
- How to get your design system under control
- Using Contentful CMS with Next.js
- Using React Native VisionCamera: Demo and alternatives
- How to create a risk register
- Matching static and dynamic patterns in Nuxt 3
- Using vue-clamp to truncate text in Vue apps
- How to build a strategic roadmap: Examples and antipatterns
- Leverage Go workspaces for multi-module local development
- Understanding sunk costs in product management
- A guide to R8 and code shrinking in Android
- Using RAID logs for strategic project documentation (with template)
- Creating a resume builder app in React Native
- Using Re.pack for large-scale React Native projects
- Storybook visual regression testing with Lost Pixel and React
- You are not your customer: How to avoid building the wrong product
- What is the 80/20 rule (Pareto Principle) in business?
- Getting started with NextUI and Next.js
- Creating Vue.js masked input fields
- A guide to visual debugging with Vitest Preview
- What are deliverables in agile and why do we have them?
- Designing a UX user flow for your app
- Creating visuals with react-native-masked-view
- Applying SOLID principles to TypeScript
- Getting started with the View Transitions API
- How to create buyer personas (with templates and examples)
- XML parsing in Swift: Tutorial with examples
- Creating a typewriter animation effect with only CSS
- Kanban vs. scrum: Choosing the right process for your team
- How to style scroll snap points with CSS
- Privacy-friendly data tracking in React with walker.js
- What is a crisis management plan? 5 steps with examples
- Build a draggable to-do list with React Native Draggable FlatList
- What are release notes and how to write good ones
- Using Medusa as a Shopify alternative
- Using msal-react for React app authentication
- CSS Grid: A guide to getting started
- 5 product management trends to monitor in 2023
- Understand users better with customer journey mapping
- panic! vs. error in Rust
- Building dynamic Vuetify themes for Vue.js applications
- Setting up a Headless Chrome Node.js server in Docker
- How to write a creative brief: Templates and guide with examples
- Using behavioral and attitudinal data in UX design
- Getting started with Android’s intent filters
- Understanding JavaScript’s Array.Group and Array.GroupToMap
- Scrum is a framework, not a silver bullet
- Getting started with SolidStart: A SolidJS framework
- Implementing a secure password reset in Node.js
- How to create a compose function in TypeScript
- Work SMARTER, not harder: How to write modern SMART goals
- How ArrowJS compares to React and Vue.js
- Automate image optimization using the TinyPNG API
- Making clear website navigation menus for better UX
- Build a Shopify app with Node.js
- How to effectively manage product risks as a product manager
- Deep dive into the CSS :where() and :is() functions
- Building an app with Qwik
- Digital monetization trends to watch in 2023
- Natural language processing with Node.js
- Build a React app using Grommet for the UI
- Creating a vertical tab layout for React Native apps
- Conversion funnel analysis: How to optimize your customer journey
- Manage SEO in Next.js with Next SEO
- Wireframing for responsive design and good UX
- Understanding neumorphism in CSS
- How to run a proper project kickoff meeting (with sample agenda)
- Create an API in Rust with SQLite and Rocket
- 18 JavaScript and TypeScript shorthands to know
- Building web components with WebC in vanilla JavaScript
- A guide to streaming SSR with React 18
- Improve operations with a product management maturity model
- Building a color palette with CSS: 3 methods