Forem: Joshua Matthews

Developer Burnout Is Real: Signs, Prevention, and Recovery

Joshua Matthews — Wed, 21 Jan 2026 19:57:33 +0000

Burnout isn't weakness. It's what happens when sustained stress exceeds recovery. Developers are particularly vulnerable.

Warning Signs

Cynicism about work you once enjoyed. Projects feel meaningless.

Exhaustion that sleep doesn't fix. Mental fatigue persists.

Declining performance despite effort. Simple tasks feel hard.

Detachment from colleagues and work. Isolation increases.

Physical symptoms. Headaches, sleep problems, changes in appetite.

Why Developers Are Vulnerable

Always-on culture. Slack notifications at midnight. Weekend deployments.

Imposter syndrome. Constant learning can feel like never being good enough.

Unclear success metrics. "Ship more features" isn't a healthy goal.

Cognitive load. Keeping complex systems in your head is exhausting.

Prevention Strategies

Set boundaries. Working hours should end. Notifications should stop.

Take actual vacation. Not working-from-beach vacation. Real disconnection.

Build non-coding interests. Your identity shouldn't be your job title.

Exercise regularly. Physical activity genuinely helps mental health.

Maintain relationships outside work. Diverse social connections matter.

Say no to some opportunities. Not every project needs you.

When You're Already Burned Out

Acknowledge it. Denial prolongs suffering.

Talk to someone. Manager, HR, therapist, friend. You're not the first.

Take time off if possible. Even a few days of genuine rest helps.

Identify what's unsustainable. What specific factors are draining you?

Make changes. Sometimes that means a new team, sometimes a new company, sometimes just new boundaries.

For Managers

Watch for signs in your team. Sudden performance drops, withdrawal, cynicism.

Model healthy behaviour. If you email at midnight, you set that expectation.

Staff appropriately. Permanent crunch mode burns people out.

Check in genuinely. "How are you?" asked with time to listen.

The Long View

Your career spans decades. Burning bright for two years then crashing isn't success.

Sustainable pace beats heroic effort. Every time.

At Logic Leap, we believe sustainable work practices are a competitive advantage. Building a team culture that prevents burnout? We've learned some things.

How do you maintain sustainable pace in your work?

Technical Documentation That People Actually Read

Joshua Matthews — Wed, 21 Jan 2026 19:54:04 +0000

Bad documentation isn't just unhelpful—it actively damages adoption. Here's how to write docs developers actually use.

The Documentation Audit

Before writing, assess: What questions do users actually have?

Support tickets reveal gaps. What do people ask repeatedly?

Search analytics show intent. What are people looking for?

User interviews surface confusion. Where do people get stuck?

The Four Types of Documentation

Tutorials guide newcomers through first experiences. Hand-holding is appropriate.

How-to guides solve specific problems. Task-focused, assume basic knowledge.

Reference documentation provides precise technical details. Completeness matters.

Explanations give context and background. Help users build mental models.

Most projects need all four. Each serves different needs.

Writing Principles

Start with what the user wants to accomplish, not what your product does.

Use concrete examples. Abstract explanations confuse; code samples clarify.

Keep paragraphs short. Scannable beats dense.

Link liberally. Users arrive at different points—help them find context.

Structure Matters

Consistent navigation. Users should always know where they are.

Progressive disclosure. Don't overwhelm upfront. Basics first, advanced later.

Searchable content. Ctrl+F is often the first interaction.

Maintenance

Docs rot. Code changes; docs lag behind.

Build docs into the development process. PR should update relevant docs.

Version docs with releases. Old versions need accessible documentation.

Set up alerts for broken links and outdated examples.

Testing Documentation

Have someone unfamiliar follow your tutorial. Watch where they struggle.

Check code examples actually run. Stale examples destroy trust.

Review regularly. Quarterly audit is a reasonable cadence.

At Logic Leap, we believe good documentation is a competitive advantage. Need help creating docs that actually get read? We can help.

What documentation practices have worked for your team?

Learning to Code in 2025: What's Changed, What Hasn't

Joshua Matthews — Wed, 21 Jan 2026 19:50:54 +0000

The path to becoming a developer has changed. But some fundamentals remain timeless.

What's Changed

AI Tools Are Part of the Workflow

New developers should learn with AI assistants, not despite them. But understand what the AI generates—don't just accept it blindly.

Frameworks Move Faster

The "right" framework changes yearly. Focus on patterns and principles that transfer between frameworks.

Remote Work Is Normal

Collaboration skills matter more than ever. Written communication, async work, self-direction.

The Bar Has Shifted

Basic tutorials aren't enough. You're competing with people who can spin up production apps with AI assistance.

What Hasn't Changed

Fundamentals Still Matter

Data structures, algorithms, how computers actually work. AI tools make this knowledge more valuable, not less.

Problem-Solving Is the Core Skill

Languages and frameworks are tools. The ability to break down problems and think systematically transfers everywhere.

Reading Code Matters More Than Writing It

You'll read far more code than you write. Practice understanding others' code.

Projects Beat Tutorials

Building something teaches more than following along. Get uncomfortable.

The Learning Path That Works

Start with one language. Python or JavaScript. Master basics before branching out.

Build projects that interest you. Motivation sustains learning.

Read documentation, not just tutorials. Primary sources beat interpretations.

Join communities. Discord servers, local meetups, online forums. Learning alone is harder.

Contribute to open source early. Real codebases teach lessons tutorials can't.

The AI Question

"Will AI replace developers?" misses the point. AI changes what developers do, not whether they're needed.

Learn to work with AI tools. Learn to verify and refine AI output. Learn the fundamentals that let you know when AI is wrong.

At Logic Leap, we help aspiring developers and career changers navigate the path to their first tech role. Starting your learning journey? We can help guide it.

What advice would you give to someone learning to code today?

Email Marketing for SaaS: The Sequences That Actually Convert

Joshua Matthews — Wed, 21 Jan 2026 19:47:37 +0000

Most email sequences are forgettable. Here's how to build sequences people actually open and act on.

The Welcome Sequence

First impressions matter. The welcome sequence sets expectations.

Email 1 (Immediate): Deliver what they signed up for. Guide them to one clear next step.

Email 2 (Day 1-2): Share your best content. Build credibility through value.

Email 3 (Day 3-4): Address the main objection or question new subscribers have.

Email 4 (Day 5-7): Soft pitch or trial invitation. They know you now—make an offer.

The Onboarding Sequence

For trial users and new customers. Get them to value quickly.

Focus on one action per email. Don't overwhelm with feature lists.

Celebrate milestones. "You just completed your first project!" reinforces progress.

Address common drop-off points. If users churn at day 3, email them on day 2.

The Re-Engagement Sequence

For users going cold. Bring them back before they're gone.

Acknowledge the absence. "We noticed you haven't logged in lately."

Remind them of value. What problem does your product solve for them?

Make it easy to return. One-click actions, direct links.

Last chance before cleaning. "Should we keep sending these?" gets responses.

Subject Lines That Get Opened

Curiosity gaps work. "The mistake most [role] make" gets clicks.

Personal beats promotional. "[First name], quick question" outperforms "New feature announcement!"

Short often wins. Mobile previews are limited.

Test constantly. Your audience is unique.

Metrics That Matter

Open rate tells you about subject lines. Click rate tells you about content.

Reply rate matters for relationship building. Engaged subscribers respond.

Unsubscribe rate signals content-audience fit. Some churn is healthy.

At Logic Leap, we help SaaS companies build email sequences that convert trials to customers. Need to improve your email game? Let's talk.

What email sequences have worked best for you?

Content Strategy for Tech Companies: What Actually Gets Shared

Joshua Matthews — Wed, 21 Jan 2026 19:44:19 +0000

Most tech company blogs sit unread. Here's what separates content that spreads from content that sinks.

Why Most Tech Content Fails

It's written for search engines, not humans. Keyword-stuffed, shallow, forgettable.

It sounds like everyone else. Same topics, same angles, same conclusions.

It lacks a point of view. Neutral summaries don't inspire sharing.

Content That Actually Works

The Contrarian Take

Challenge conventional wisdom with evidence. "You don't need microservices" gets more engagement than "10 benefits of microservices."

Be willing to be wrong publicly. Strong opinions, loosely held.

The Battle-Tested Lesson

Share what you actually learned building something. Specific details beat generic advice.

Include failures. "What didn't work" is often more valuable than "what worked."

The Definitive Resource

Create the reference you wished existed. Be comprehensive enough that people bookmark it.

Update it regularly. Evergreen content requires maintenance.

The Data Story

Original research or analysis. Numbers give people something to share and cite.

Visualise data compellingly. Good charts get embedded everywhere.

Distribution Strategy

Don't just publish and pray.

Share in relevant communities. But add value, don't just drop links.

Engage with responses. Discussion extends reach.

Email list matters. Owned audience beats algorithmic reach.

Repurpose across formats. Blog post becomes thread becomes video becomes podcast clip.

Metrics That Matter

Time on page over pageviews. Did they actually read it?

Return visitors over uniques. Are you building an audience?

Backlinks over social shares. Long-term authority signals.

The Consistency Factor

One great post per month beats four mediocre posts per week. Quality compounds.

At Logic Leap, we help tech companies create content worth reading. Need a content strategy that actually works? We should talk.

What content has performed best for your company?

Accessibility Isn't a Feature: Building Inclusive Interfaces

Joshua Matthews — Wed, 21 Jan 2026 19:40:56 +0000

Accessibility isn't an extra feature to add later. It's a quality of good engineering that benefits everyone.

The Business Case

15% of the global population has some form of disability. That's a massive user base you might be excluding.

Legal requirements exist in many jurisdictions. WCAG compliance isn't optional for many organisations.

Accessible interfaces are often better for everyone. Captions help in noisy environments. Good contrast helps in bright sunlight.

The Foundation: Semantic HTML

Most accessibility problems come from breaking HTML's built-in accessibility.

Use buttons for actions. Not divs with click handlers.

Use links for navigation. Screen readers announce them differently than buttons.

Use headings in order. h1, then h2, then h3. Don't skip levels for styling.

Use form labels. Every input needs an associated label. Placeholders aren't labels.

Keyboard Navigation

Can you use your entire interface without a mouse? Tab through it. Can you reach everything? Can you see where focus is?

Focus indicators matter. Don't remove outlines without providing alternatives.

Tab order should match visual order. Unexpected tab sequences confuse users.

Screen Reader Essentials

Alt text for images. Describe what the image conveys, not what it looks like.

ARIA labels when semantic HTML isn't enough. But semantic HTML first—ARIA is a last resort.

Live regions for dynamic content. Announce changes that users need to know about.

Colour and Contrast

4.5:1 contrast ratio for normal text. 3:1 for large text. Test with tools, not eyeballing.

Don't rely on colour alone. Use icons, patterns, or text alongside colour coding.

Testing

Use your keyboard. Use a screen reader. Lighthouse and axe-core catch many issues automatically.

Include users with disabilities in testing. Automated tools miss context.

At Logic Leap, we believe accessibility is part of quality engineering, not an afterthought. Need help building inclusive interfaces? We can help.

What accessibility improvements have had the most impact on your projects?

Authentication Patterns: JWTs, Sessions, and When to Use Each

Joshua Matthews — Wed, 21 Jan 2026 19:37:18 +0000

"Should I use JWTs or sessions?" is the wrong question. The right question is "What are my requirements?"

The Session-Based Pattern

Server stores session data. Client gets a session ID in a cookie. Simple, proven, well-understood.

Advantages:
Server can invalidate sessions instantly. User logs out everywhere immediately.
Session data stays server-side. Client can't tamper with it.
Works naturally with HTTP-only cookies. Better XSS protection.

Disadvantages:
Server state required. Every request needs session lookup.
Scaling complexity. Sessions need shared storage across servers.
Cookie limitations for cross-domain scenarios.

The JWT Pattern

Token contains claims, signed by server. Client stores and sends token. Server verifies signature without state.

Advantages:
Stateless on the server. No session storage needed.
Works well for APIs. Easy to use in headers.
Cross-domain friendly. Not tied to cookies.

Disadvantages:
Can't truly revoke tokens before expiry. Only workarounds (blocklists, short expiry).
Token size. JWTs are larger than session IDs.
Complexity. Refresh tokens, token storage decisions, signature algorithms.

When to Choose Sessions

Traditional web apps with server rendering. Sessions work naturally with cookies.
You need instant invalidation. Logout must mean logout.
Simpler security model preferred. Fewer moving parts to secure.

When to Choose JWTs

API-first architectures. Mobile apps, SPAs talking to APIs.
Microservices. Services can verify tokens without central session store.
Short-lived authorisation. Where token expiry is acceptable revocation.

The Hybrid Approach

Many systems use both. Sessions for web clients, JWTs for API access. Refresh tokens for mobile apps.

Security Fundamentals (Either Way)

Use HTTPS everywhere. Authentication without encryption is theatre.
Hash passwords properly. bcrypt, Argon2. Never MD5 or SHA1.
Rate limit authentication endpoints. Prevent brute force.
Implement proper logout. Don't just clear client state.

At Logic Leap, we help teams implement authentication correctly the first time. Security architecture questions? Let's talk.

What authentication patterns have worked for you?

Performance Budgets: The Metric That Changes Everything

Joshua Matthews — Wed, 21 Jan 2026 19:33:48 +0000

Performance optimisation without a budget is just guessing. Here's how to set meaningful limits and stick to them.

What's a Performance Budget?

A performance budget is a limit on metrics that affect user experience. Not a target—a ceiling you won't exceed.

Example: Main bundle under 200KB. Time to interactive under 3 seconds on 4G. No more than 50 requests on initial load.

Why Budgets Work

Budgets create accountability. "We need to keep the bundle under 200KB" is actionable. "We should improve performance" is not.

Budgets prevent regression. That new library looks nice—but does it fit the budget?

Budgets force trade-offs. When you can't have everything, you prioritise what matters.

Setting Meaningful Budgets

Start with user research. What devices and connections do your users have? Budget for your actual audience, not your dev machines.

Benchmark competitors. If competitors load in 2 seconds and you take 5, you're losing users.

Use real metrics. Core Web Vitals (LCP, FID, CLS) map to user experience better than raw transfer size.

Enforcing Budgets

Build-time checks. Fail the build if bundle size exceeds limits. webpack-bundle-analyzer, bundlesize, size-limit.

CI integration. Lighthouse CI can fail builds that miss performance targets.

Monitoring. Track real user metrics. Synthetic tests don't catch everything.

Budget Examples

JavaScript: Total JS under 300KB compressed. Main bundle under 150KB.

Images: Largest image under 200KB. Prefer modern formats (WebP, AVIF).

Fonts: Maximum 2 font families. Subset to needed characters.

Third parties: Total third-party scripts under 100KB. Audit regularly.

When to Exceed the Budget

Sometimes you must. But make it explicit. "We're exceeding the JS budget by 50KB for feature X. Here's the justification."

Document the decision. Future you will want to know why.

At Logic Leap, we help teams establish performance cultures that stick. Need help setting and maintaining performance standards? Let's talk.

What performance budgets have worked for your team?

Testing Mobile Apps: Beyond "It Works on My Device"

Joshua Matthews — Wed, 21 Jan 2026 19:30:30 +0000

"It works on my device" is the most dangerous phrase in mobile development. Here's how to actually test mobile apps.

The Device Fragmentation Problem

Android alone has thousands of device configurations. iOS versions matter. Screen sizes vary. Your test device isn't representative.

The Testing Pyramid for Mobile

Unit tests form the foundation. Business logic should be testable without a device.

Integration tests verify component interactions. API calls, database operations, state management.

UI tests validate user flows. But keep them focused—UI tests are slow and flaky.

Manual testing remains essential. Some things can't be automated effectively.

Real-World Conditions to Test

Network variability. Test on 3G. Test with packet loss. Test offline transitions.

Battery states. Low battery changes OS behaviour. Background processing gets restricted.

Interruptions. Phone calls, notifications, app switching—your app will be interrupted.

Memory pressure. What happens when the OS kills your background app?

Device Coverage Strategy

Physical devices for critical paths. Emulators can't replicate everything.

Cloud testing services for breadth. AWS Device Farm, Firebase Test Lab, BrowserStack.

Focus on market share. Test the devices your users actually have.

Don't chase the long tail. Supporting every device isn't cost-effective.

Crash Reporting Is Non-Negotiable

Implement crash reporting from day one. Crashlytics, Sentry, Bugsnag—pick one.

Monitor crash-free rates by device and OS version. Patterns reveal systematic issues.

The Release Strategy

Beta testing catches user-facing issues. TestFlight, Google Play Internal Testing.

Staged rollouts limit blast radius. Don't ship to 100% immediately.

Have a rollback plan. You will need it eventually.

At Logic Leap, we help teams build testing strategies that catch issues before users do. Need help establishing a QA process? Let's connect.

What's your mobile testing approach?

Cross-Platform vs Native: The Question You're Actually Asking

Joshua Matthews — Wed, 21 Jan 2026 19:27:05 +0000

The cross-platform vs native debate misses the point. The real question isn't "which technology?"—it's "what are we optimising for?"

The Wrong Questions

"Is React Native good enough?"
"Is Flutter ready for production?"
"Should we use Swift or Kotlin?"

The Right Questions

"What's our timeline to market?"
"What's our development budget?"
"How much native functionality do we need?"
"What's our team's existing expertise?"
"How important is performance for our use case?"

When Cross-Platform Wins

You're testing market fit. Building two native apps to validate an idea is expensive. Cross-platform gets you to users faster.

Your app is content-focused. News apps, social feeds, e-commerce—these don't need deep OS integration.

Your team knows JavaScript/Dart. Learning Swift AND Kotlin takes time. Leverage existing skills.

Time matters more than perfection. First-mover advantage sometimes outweighs pixel-perfect native experience.

When Native Wins

Performance is your product. Games, video editing, AR apps—these need every bit of hardware optimization.

Deep OS integration is essential. HealthKit, background processing, hardware accessories—some features require native access.

You're building for longevity. Native apps age better with OS updates. Cross-platform frameworks have migration costs.

You have the resources. If you can afford two teams, two codebases can mean two better apps.

The Hybrid Approach

Many successful apps use cross-platform for most features and native modules for performance-critical sections. You don't have to choose one path entirely.

The Honest Answer

There is no universally correct choice. There's only the right choice for your constraints, today.

At Logic Leap, we help teams choose the right approach for their specific situation—not the one that's trendy this year. Facing this decision? Let's work through it together.

What drove your last platform decision?

Building a Personal Claude Code Toolkit: Templates and Snippets

Joshua Matthews — Wed, 21 Jan 2026 19:23:56 +0000

The best developers have toolkits. With Claude Code, your toolkit becomes a collection of refined prompts and patterns.

Why Build a Toolkit?

Great prompts are discovered, not invented. When you find something that works, save it. Refine it. Reuse it.

My Essential Templates

The Debug Template

"I'm seeing [error/behaviour]. Expected: [what should happen]. Actual: [what's happening]. Relevant code: [paste]. What are the most likely causes and how do I diagnose each?"

The Architecture Review Template

"I'm building [feature] with [constraints]. Here's my proposed approach: [description]. What are the trade-offs? What alternatives should I consider? What will I regret in 6 months?"

The Learning Accelerator

"Explain [concept] as if teaching a developer who understands [related concept] but not [this concept]. Use analogies from [their domain]."

The Test Generator

"Generate tests for [function] that cover: happy path, edge cases, error conditions, boundary values. Include setup and teardown. Format for [testing framework]."

The Documentation Writer

"Document [code] for three audiences: a quick reference for experienced users, a detailed guide for new team members, and inline comments explaining the 'why'."

Building Your Own

Start by saving prompts that get good results. After each session, ask yourself: "Would I use this prompt again?" If yes, save it.

Refine by iteration. Each time you use a template, note what worked and what didn't. Update the template.

Organise by task. Group prompts by what you're trying to accomplish: debugging, documentation, learning, code generation.

The Meta-Toolkit

The most powerful prompt: "I want to accomplish [goal]. What questions should I be asking you to get the best result?"

Let Claude Code help you build better prompts.

At Logic Leap, we help teams develop systematic approaches to AI-assisted development. Want to build a team-wide prompt toolkit? We can help.

Share your favourite prompt templates below!

Code Review With Claude Code: A Practical Checklist

Joshua Matthews — Wed, 21 Jan 2026 19:20:51 +0000

Code reviews catch bugs, but they also teach. Here's how I use Claude Code to make both processes more effective.

The Pre-Review Checklist

Before pushing code for human review, I run it through Claude Code with specific prompts.

1. Logic Verification

"Walk through this function step by step. What are the edge cases I haven't handled?"

This catches the obvious gaps before a colleague has to.

2. Security Scan

"Review this code for common security vulnerabilities: SQL injection, XSS, improper authentication, exposed secrets."

Not a replacement for proper security tools, but catches low-hanging fruit.

3. Performance Questions

"Where are the potential performance bottlenecks in this code? Are there any O(n²) operations hidden in loops?"

4. Readability Check

"If a new developer joined the team tomorrow, what parts of this code would confuse them?"

This question surfaces naming issues, missing comments, and overly clever solutions.

5. Test Coverage

"What test cases would you write for this function? What boundary conditions should I cover?"

The Post-Review Learning Loop

After receiving feedback from human reviewers, I share the comments with Claude Code:

"My colleague suggested [feedback]. Can you explain why this approach is better and show me an example?"

This transforms review comments into learning opportunities.

What Claude Code Won't Catch

Domain-specific logic errors. Business requirement misalignment. Team conventions that aren't codified. Always pair AI review with human review.

At Logic Leap, we believe in augmenting human expertise with AI tools—not replacing it. Need help building effective code review processes? Let's talk.

What's your code review workflow?