Forem: Spencer Marx

RELEASE THE HORDE!! 🤖 Haha, but seriously, for fans (or anti-fans) of Gastown, this one is for you... a simple lightweight orchestration engine that drops in, can manage any number of your projects, and stays out of the way. 5 min to get up and running 💪

Spencer Marx — Thu, 19 Mar 2026 16:15:27 +0000

Spencer Marx

Mar 19

Release the Horde: Multi-Agent Orchestration in Pure Bash

#ai #opensource #bash #devtools

Comments 3

3 min read

Release the Horde: Multi-Agent Orchestration in Pure Bash

Spencer Marx — Thu, 19 Mar 2026 16:10:12 +0000

Anyone running 3+ AI coding agents in parallel has hit the same wall: the agents are fine. The coordination is the problem.

Merge conflicts. Duplicated work. No review gate. Token burn on orchestration overhead. You end up spending more time managing agents than the agents save you.

So I built Orc.

What it does

You describe the work. Orc decomposes it into goals and beads (focused work items), spawns engineers in isolated git worktrees, reviews everything before merge, and delivers clean goal branches.

Across multiple projects, from a single session.

"Fix auth, add rate limiting, update docs"
                  │
                  ▼
          ┌──── orc ────┐
          │      │      │
          ▼      ▼      ▼
    fix/auth  feat/rate  task/docs      ← goal branches
      │   │      │         │
     [E] [E]    [E]       [E]           ← engineers in isolated worktrees
      │   │      │         │
     ✓/✗ ✓/✗    ✓/✗       ✓/✗           ← built-in review loop
      │   │      │         │
    fix/auth  feat/rate  task/docs      ← approved beads merge back
          │      │         │
          You review & merge            ← you decide when to ship

The whole stack

Bash. Tmux. Git worktrees.

No daemon. No server. No framework. No build step. State is three files. You're running in five minutes.

# Register a project
orc add myapp /path/to/myapp

# Launch
orc myapp

# Or go full send
orc myapp --yolo

Opinionated but stays out of your way

This is where it gets interesting. Orc has strong opinions about structure (four-tier hierarchy, mandatory review before merge, hard role boundaries), but the things you actually care about customizing are wide open.

The review loop is mandatory. How you review is yours. Swap in your own review command, point it at a multi-agent review tool, or just describe your review standards in plain English:

[review]
command = "/ocr:review"  # your tool, or leave blank for built-in

instructions = """
Focus on security: check for SQL injection, XSS, and auth bypass.
All new endpoints must have rate limiting.
Verify error responses follow our RFC 7807 format.
"""

Branch naming? Natural language:

[branching]
strategy = "use Jira ticket prefix like PROJ-123, then kebab-case summary"

Delivery strategy? Same pattern:

[delivery]
mode = "pr"
target_strategy = "target develop for features, main for hotfixes"

Most of the configuration is "tell it what you want in plain English." Orc interprets it.

Token efficiency by design

Coordination happens through the filesystem, not agent-to-agent conversation. An engineer writes review to a .worker-status file. The orchestrator reads the file. Zero tokens burned on supervisors polling workers or nudging stalled agents.

The tools you already have (tmux for sessions, git worktrees for isolation, the filesystem for signals) solve most of the orchestration problem. The interesting part is the decomposition, dispatch, and review protocol on top.

YOLO mode

Sometimes you don't want to babysit.

orc myapp --yolo

All approval gates are skipped. Planning flows straight into dispatch. Agents launch with auto-accept flags.

But it still escalates on merge conflicts, blocked engineers, and out-of-scope discoveries. We're not animals.

Works with your agent

Claude Code, OpenCode, Codex, or bring your own. Personas are markdown files you can override per-project. Adding a new agent is a single adapter.

Credit where it's due

Huge respect to Gas Town for proving this category matters and pushing everyone's thinking forward. Orc asked "what's the minimum viable version of this?"

Try it

git clone https://github.com/spencermarx/orc.git
cd orc && pnpm install
pnpm orc:install
orc add myapp /path/to/your/project
orc myapp

Now go. Release the horde.

GitHub: spencermarx/orc

Star it if it's useful. PRs are welcome. Issues too.

Open Code Review changed AI-Assisted Dev for our team

Spencer Marx — Wed, 11 Mar 2026 14:55:40 +0000

Spencer Marx

Mar 11

Your AI code reviewer has no one to disagree with

#opensource #ai #codereview #claudecode

Comments 4

5 min read

Your AI code reviewer has no one to disagree with

Spencer Marx — Wed, 11 Mar 2026 14:48:03 +0000

Ask an AI to review your code and you get one model's opinion. One pass through the diff. Whatever it happens to focus on first.

Sometimes that's fine. Sometimes it catches real stuff.

But if you've ever been on a team with strong review culture you know that's not how the best reviews work. The best reviews happen when people with different concerns look at the same code and then argue about what they found.

The security person flags something. The architect says "actually that's fine because of how we structured X." The quality engineer notices they're both missing an error handling gap that connects the two findings. The conversation surfaces things no individual reviewer would have caught alone.

That back-and-forth is where the real signal lives. And every AI code review tool I've tried just... skips it entirely.

One pass is a coin flip with better marketing

Here's what bugs me about the current crop of AI review tools.

They're all doing fundamentally the same thing: take a diff, throw it at a model, format the output nicely. Some add project context. Some run multiple checks in parallel. But at the end of the day you're getting a single perspective, uncontested, with nobody pushing back on whether the findings are actually real.

You know what you get from an uncontested review? False positives. Hallucinated findings. Surface-level nitpicks dressed up as critical issues. And occasionally, actually useful feedback buried somewhere in the noise.

Sound familiar? It should. It's the same reason a single human reviewer isn't sufficient for important code either. We solved this decades ago with the concept of multiple reviewers. It just took us a while to apply the same logic to the AI versions.

What if the reviewers actually talked to each other?

This is the question that led to Open Code Review.

I started building it as an internal tool for our team because we were frustrated with exactly the problem above. The idea was stupid simple: what if we structured AI code review the same way high performing engineering teams actually do it?

So here's how it works:

You configure a team of reviewers with specific roles. Architecture, security, code quality, testing, whatever custom roles make sense for your codebase.
Each reviewer does their pass independently. Different concerns, different focus areas, different findings.
Then comes the part that actually matters: a structured discourse step where they debate each other's findings. Agree, challenge, connect related issues, surface new concerns.
Only then does a final synthesis produce the review you actually see.

                    ┌─────────────┐
                    │  Tech Lead  │  ← Orchestrates
                    └──────┬──────┘
                           │
         ┌─────────────────┼─────────────────┐
         ▼                 ▼                 ▼
   ┌───────────┐    ┌───────────┐    ┌───────────┐
   │Principal×2│    │ Quality×2 │    │ Security  │
   └───────────┘    └───────────┘    └───────────┘
         │                 │                 │
         └─────────────────┼─────────────────┘
                           ▼
                    ┌─────────────┐
                    │  Discourse  │  ← They argue
                    └──────┬──────┘
                           ▼
                    ┌─────────────┐
                    │  Synthesis  │  ← You get this
                    └─────────────┘

That discourse step is the entire point. Every finding gets pressure tested by reviewers with different perspectives before it reaches you. Hallucinated issues get challenged. Connected problems get linked. Blind spots get exposed.

The result is way fewer false positives and way more signal. Not because any individual reviewer is smarter, but because contested findings are just higher quality than uncontested ones. Same reason peer review works for humans.

Customizable to the moon (or just use the defaults)

Your codebase isn't generic and your review team shouldn't be either.

# .ocr/config.yaml
default_team:
  principal: 2    # Architecture, design
  quality: 2      # Code style, best practices
  security: 1     # Auth, data handling
  testing: 1      # Coverage, edge cases

Need heavier security scrutiny for a payments service? Bump it to 3. Building something performance-sensitive? Create a custom reviewer:

# .ocr/skills/references/reviewers/performance.md

# Performance Engineer

You are a performance-focused code reviewer. {ADD MORE HERE}

## Focus Areas
- Response times and latency
- Memory usage and leaks
- Database query efficiency
- N+1 queries, unbounded loops, missing indexes
- {ADD MORE HERE}

Build these from the dashboard, or drop that file in and tell OCR to use it, and now it participates in discourse alongside everyone else. It challenges the other reviewers and gets challenged right back.

Or don't think about any of this and just run it with the built-in templates. It works out of the box.

It knows about your requirements, not just "best practices"

This is the other thing that drives me nuts about most review tools. They evaluate your code against generic best practices and have no concept of what you were actually trying to build.

OCR lets you pass in a spec, a proposal, acceptance criteria from a ticket, whatever:

/ocr-review Review my staged changes against openspec/specs/cli/spec.md

Every reviewer evaluates the code against both their expertise and your stated requirements. The final synthesis includes a requirements verification showing what's met, what's got gaps, and what's ambiguous.

If you're doing any kind of spec-driven development this is where it really clicks. We were partly inspired by OpenSpec on this front.

Drops in, stays out of the way

I cannot stress enough how little this should disrupt your existing workflow. It was a core design goal.

npm install -g @open-code-review/cli
cd your-project
ocr init

It auto-detects whatever agentic environment you're using. Claude Code, Opencode, Cursor, Windsurf, GitHub Copilot, doesn't matter. Stage your changes, run /ocr-review, done. There's a local-first dashboard if you want to watch progress in real-time. You can post reviews directly to your PR with /ocr-post.

Two minutes to try. No SaaS. No per-seat pricing. Free and open source.

So is it actually better?

Our team hasn't gone back to anything else. The review quality just isn't close.

And I think that comes down to something really simple: an uncontested opinion is worth less than a contested one. It doesn't matter how smart the model is. If nothing pushes back on its findings before they reach you, you're going to spend your time filtering noise instead of acting on real issues.

Make the reviewers argue first. Get the noise out before it's your problem.

GitHub: github.com/spencermarx/open-code-review

If you try it out I'd love to hear how it goes. Still early days and the feedback has been shaping this thing significantly.

CRM Development: Unlocking Growth with Custom Solutions

Spencer Marx — Tue, 14 Jan 2025 15:05:02 +0000

Transform Your Business with Custom CRM Development 🚀

👉 Read the full blog post for detailed insights here.

Customer Relationship Management (CRM) systems are no longer just "nice-to-have" tools—they’re essential for businesses that want to grow, streamline operations, and keep customers coming back. But here’s the catch: generic CRMs can’t always meet your unique needs.

This is where custom CRM development comes in. Imagine a system built specifically for your workflows, seamlessly integrating with your existing tools, and adapting to your business as it scales. Sound good? Let’s break it down.

Why Custom CRM Development? 🤔

Tailored to Your Needs: From industry-specific workflows to advanced compliance (think HIPAA or GDPR), a custom CRM aligns perfectly with your business.
Streamlined Integrations: Whether it’s ERP, marketing tools, or accounting software, custom solutions connect your systems for seamless data sharing.
Scalable and Future-Ready: Grow your CRM alongside your business without the limitations of off-the-shelf tools.

What’s Inside a Great CRM? 🌟

Custom CRMs are built with the essentials and then some:

Workflow Automation: Say goodbye to manual tasks with automated reminders, lead scoring, and pipeline updates.
Advanced Reporting: Get real-time insights into customer behavior, sales performance, and marketing ROI.
User-Friendly Design: Intuitive dashboards and responsive layouts make adoption easy for your team.

Overcome CRM Challenges with Ease 💡

Unified Data: Stop juggling multiple tools. A custom CRM gives you a 360° view of each customer.
Enhanced Security: Meet industry compliance standards with role-based access and robust encryption.
High Adoption Rates: Custom CRMs are designed for your team’s exact needs, making them easier to use and love.

Ready to Take the Next Step? 👨‍💻👩‍💻

Whether you’re building a CRM from scratch or upgrading a legacy system, Aclarify’s custom CRM development services can guide you every step of the way.

💡 Explore the full blog post for an in-depth guide: Read it here.

📩 Want a custom CRM built for your business? Contact us today!

Let’s build something extraordinary together.

Unlocking the Power of the ServiceTitan API for Custom Integrations

Spencer Marx — Thu, 09 Jan 2025 09:44:25 +0000

Supercharge Your Operations with the ServiceTitan API 🚀

👉 Read the full blog post for in-depth guidance here.

Ever felt limited by your out-of-the-box software? With the ServiceTitan API, service-based businesses like HVAC, plumbing, and electrical companies can go beyond standard workflows. Imagine automating tasks, syncing data across platforms, and crafting custom tools that directly fit your needs. Intrigued? Let’s dive in.

Why Use the ServiceTitan API? 🤔

Here’s how this API can transform your operations:

Seamless Integrations: Connect ServiceTitan with CRMs, ERPs, or reporting tools like Salesforce and Power BI.
Task Automation: Eliminate manual data entry by triggering emails, Slack alerts, or CRM updates.
Custom Solutions: Build dashboards, tools, or client-facing apps tailored to your business.
Break Down Silos: Enable real-time data exchange, reducing errors and streamlining workflows.
Scalability: Expand your integrations as your business grows.

A Built-In Shortcut: Postman Starter Collection 💡

Getting started with the ServiceTitan API is easier than ever, thanks to our pre-configured Postman starter collection.

Here’s what’s included:

Environment Variables: Pre-set fields for tenant IDs, client secrets, and base URLs to simplify setup.
Pre-Request Script for Authentication: Automatically fetches OAuth tokens using your credentials. No manual copy-pasting required!
Sample Endpoints: Prebuilt requests for essential operations like fetching technicians, invoices, and customer details.

👉 Download the Postman Starter Collection here and jumpstart your integration testing today.

Get Started with the ServiceTitan API in 5 Steps

To begin your API journey, follow these steps:

Request API Access: Sign up via the ServiceTitan Developer Portal.
Set Up Your App: Define your app’s name, scope, and permissions in the portal.
Authorize in ServiceTitan: Connect your app in the ServiceTitan UI and generate credentials like Client ID and Client Secret.
Test with Postman: Import our starter collection and make your first authenticated request in minutes.
Build Your Integration: Start small—sync invoices or automate customer updates—then scale.

Real-World Use Cases 🌟

Here are just a few examples of what’s possible:

Two-Way Accounting Sync: Connect ServiceTitan with QuickBooks or Xero to automate invoices and payments.
Advanced Reporting: Export job data to Power BI or Tableau for deeper insights.
Inventory Management: Track stock levels and equipment life cycles across systems.
Automated Marketing: Trigger campaigns based on job completions or renewals.
IoT Integration: Sync real-time device data to your workflows.

The possibilities are endless with the ServiceTitan API.

Developers, Ready to Dive In? 👨‍💻👩‍💻

If you’re a developer eager to create meaningful integrations or a service business looking for custom solutions, Aclarify can help.

💡 Explore the full blog post for step-by-step guidance: Read it here.

📩 Curious about how we can help? Contact us today!

Let’s build something extraordinary together.

What is Nearshore Software Development and Why Does It Matter?

Spencer Marx — Thu, 09 Jan 2025 09:17:05 +0000

Nearshore Software Development: Where Talent Meets Collaboration 🚀

Imagine collaborating with skilled developers who work in nearly the same time zone, share your work culture, and deliver exceptional results—all without skyrocketing costs. Welcome to nearshore software development, a model that’s transforming how modern businesses scale their tech teams.

At Aclarify, we’ve perfected this approach. With offices in the US and Spain and teams across Italy, Argentina, Ukraine, West Africa, we bridge global talent with seamless workflows to help companies thrive. Curious about how we make it work? Keep reading—or dive deeper in our blog post for a complete guide. 🌍

Why Nearshore Development? 🌟

Time Zone Alignment: Forget the long delays of offshore teams. Nearshore developers work just hours apart, making real-time collaboration a breeze.
Cultural Fit: Similar work ethics and shared values ensure smooth communication and strong team dynamics.
Cost Savings: Nearshore rates strike a perfect balance—more affordable than onshore and without the challenges of offshore.
Scalable Talent: Expand your team quickly with vetted engineers who integrate seamlessly into your workflows.

What Sets Nearshore Apart? 🤔

Factor	Onshore	Nearshore	Offshore
Location	Same country	Nearby country	Different continent
Cost	$$$$	$$-$$$	$
Time Zone Overlap	Full	High/Partial	Minimal
Cultural Alignment	Strong	Moderate to High	Low

Nearshoring combines the best of both worlds—agility and cultural alignment without the high costs of onshore or the barriers of offshore.

Developers, This One's For You 👩‍💻👨‍💻

Looking to join a dynamic, distributed team that collaborates across continents? At Aclarify, we’re always on the lookout for talented developers passionate about solving complex challenges and creating cutting-edge solutions. Our global presence means you’ll work with diverse teams, gain unique perspectives, and have the chance to make a real impact.

💡 Discover what it’s like to work at Aclarify and meet our team: Learn more here.

📩 Interested in joining us? Contact us directly to explore career opportunities.

Ready to Dive Deeper? 🔗

For an in-depth exploration of nearshore software development, its benefits, and how to choose the right partner, check out our full blog post:

➡️ Read the Full Blog Here.

🌟 Curious about career opportunities? Get in touch today!

We’d love to connect and create something extraordinary together.

Wrestling with Google Tag Manager (GTM) and Consent Mode in a Next.js project? We've got you covered 💪

Spencer Marx — Thu, 05 Dec 2024 15:33:50 +0000

Integrating Google Tag Manager with Consent Mode in NextJS 15

Spencer Marx ・ Dec 5 '24

#nextjs #react #googletagmanager #consentmode

Integrating Google Tag Manager with Consent Mode in NextJS 15

Spencer Marx — Thu, 05 Dec 2024 13:53:01 +0000

Simplifying Analytics and Privacy Compliance in NextJS 15

For modern developers, integrating Google Tag Manager (GTM) and Consent Mode into NextJS 15 apps isn’t just a best practice—it’s a necessity. But the reality? It’s far from straightforward.

Privacy regulations like GDPR and CCPA require careful handling of consent states, while NextJS 15’s limitations add layers of complexity to embedding GTM scripts dynamically. The result? Many developers struggle to implement compliant analytics systems without compromising user experience or functionality.

Why This Guide?

This tutorial was built with one goal: to address the most common and frustrating challenges developers face when integrating GTM and Consent Mode into NextJS 15 projects.

Here’s what makes this guide different:

NextJS’s Limitations: Tools like @next/third-parties don’t offer robust support for Consent Mode. Specifically, they lack solutions for managing default consent states before loading cached consent values—a critical gap we solve in this guide.
Documentation Gaps: The official guides and third-party libraries provide fragmented examples, often failing to address how to fully integrate GTM, Consent Mode, and cookie banners into a seamless, scalable NextJS app.
A Proven, Hands-On Approach: This isn’t theoretical. The solutions we present are battle-tested, combining best practices with extended functionality to ensure both analytics precision and privacy compliance.

What You’ll Gain

Step-by-Step Implementation: Learn how to integrate GTM scripts, manage dynamic consent states, and set up analytics in a privacy-first web environment.
TypeScript-First Utilities: Build reusable, strongly-typed functions to track user events and manage cookie preferences.
Working Example Repository: Clone our project to see the complete implementation in action. Compare your work at each step, ensuring your setup aligns with best practices.

Access the Codebase

Start with the initial boilerplate and follow the phased approach detailed in the guide. Each branch demonstrates a critical step in the integration process.

# Clone the Repository
git clone https://github.com/spencermarx/aclarify-blog-example--gtm-with-consent-in-nextjs.git

# Navigate to the Project Directory
cd aclarify-blog-example--gtm-with-consent-in-nextjs

# Checkout the First Phase
git checkout phase/0-initial-boilerplate

# Install Dependencies and Run
npm install
npm run dev

With this repo, you’ll have a reliable reference point for every phase of the implementation.

Why Read This Guide?

By the end of this tutorial, you’ll:

Master the complexities of embedding GTM scripts dynamically in NextJS 15 without performance trade-offs.
Implement a cookie consent banner to handle privacy-first tracking and comply with regulations like GDPR and CCPA.
Gain confidence in testing and debugging with tools like Google Tag Assistant.
Build a robust, scalable solution for managing analytics in modern NextJS projects.

Ready to tackle analytics integration while keeping privacy compliance in check?

➡️ Read the Full Guide and Explore the Repository on Aclarify’s Blog here ⬅️

About Aclarify: We empower developers to build modern, privacy-compliant solutions with cutting-edge tools like NextJS, Google Tag Manager, and Consent Mode. Join us to streamline your development process and achieve your goals.

Build a Seamless ServiceTitan Integration with Next.js: A Modern, Full-Stack Guide

Spencer Marx — Mon, 28 Oct 2024 20:40:00 +0000

Supercharge Your Service Business with a Custom ServiceTitan Integration

In the service industry—covering essential businesses like HVAC, plumbing, electrical services, and beyond—streamlined operations are key to profitability. But for companies using ServiceTitan, one of the most popular platforms for managing scheduling, dispatch, and customer communication, there's a common roadblock: the API documentation and examples are, well, limited. (Queue sad face 😢)

If you're trying to build custom solutions, you may find yourself hunting for real-world examples or best practices to get started.

That’s where Aclarify comes in.

Our latest blog post dives into a comprehensive, step-by-step guide to building a custom integration between ServiceTitan and a modern Next.js application. And this isn’t just another tutorial—it’s packed with practical insights, code examples, and solutions to common challenges that aren’t covered anywhere else.

What’s Inside?

Demo Repository: Access a fully built-out repository with a modern Next.js setup and pre-built ServiceTitan integration components. Perfect for exploring, modifying, and understanding best practices in a hands-on way.
Full-Stack Type Safety: Learn how to manage full-stack typing with TypeScript for a ServiceTitan API endpoint, ensuring your data flow is both reliable and maintainable across the backend and frontend.
Real-World Examples: From handling ServiceTitan API authentication to implementing booking forms with custom workflows, this guide is packed with code snippets and solutions you can actually use.
Enterprise-Grade Practices: The architecture and stack choices in this guide reflect standards seen at enterprise companies—TypeScript, Tailwind CSS, React hooks, server actions in Next.js, and secure API handling.

Why This Guide is a Must-Read

This is one of the only comprehensive resources out there for developers and technical teams who need to work with ServiceTitan. Unlike typical guides, it’s designed to help you:

Save time by avoiding common pitfalls in ServiceTitan’s API.
Go beyond the basics, with a highly modular and scalable architecture.
Gain insights on integrating with ServiceTitan’s complex API, which doesn’t have extensive documentation for developers.

By the end of the tutorial, you’ll not only have a working integration—you’ll have a blueprint for building future-proof, customized solutions that streamline operations and delight your customers.

Read the full guide on Aclarify's website and access the demo repo, code samples, and more.

About Aclarify: We specialize in developing custom software solutions that transform service-based businesses. From field service operations to customer engagement, our technology-driven approach helps companies achieve seamless, modern workflows.

7 Tips for Getting Your First Developer Job

Spencer Marx — Thu, 01 Jul 2021 17:39:18 +0000

⭐️ Note: The original edition of this tutorial can be found on my site here!

The software engineering space is booming right now🚀 With the pandemic increasing demand for digital services across a spectrum of industries, the appeal of becoming a developer has increased profoundly. And market analyses only further optimism — for example, the U.S. Bureau of Labor Statistics projects software engineering job growth to reach 22% over the next decade. That's massive! In summary, this is a great time to break into the software development space.

As someone looking to get a job in this space, it’s more important now than ever that you present yourself as not only competent, but uniquely suited for roles to which you apply. But hunting for your first developer job is no easy feat, and it can be especially overwhelming when it comes down to figuring out where to start. 🤷‍♀️🤷‍♂️

As a Director and Senior Software Engineer who has sat on both sides of the interview table, here are the 7 tips I wish someone had given me when I was embarking on the hunt for my first job as a developer...

1 | Make sure you are comfortable across a single tech stack

This is probably pretty obvious to most, but if you are going to apply to a position that works within, say, the MERN stack (Mongo, Express, React, Node), you should be familiar with each element in that stack. There may be few exceptions where a company is looking to switch to some novel technology or framework and thus is flexible on the incoming engineers' stacks, but more often than not, you should already be able to navigate and effectively use whatever tech the job is set to use on a day-to-day basis.

One important note here is that "comfortable" can mean different things to different people. In this context, "comfortable" means being able to do the basic things across the various elements of the stack. Think...

Writing out routes on an Express + Node server
Building out functional and class components in React
Implementing CRUD operations with Node + Mongo
Creating authentication middleware within Express

The idea is: you want to be prepared to jump into whatever job you land and contribute quickly. Therefore, you should know your way around your tech stack as it'll likely be the stack you're hired to work within.

⭐️ Note: Try to include a standard unit testing framework in your stack (like Jest or Mocha). This is often overlooked when evaluating devs at small to midsize software companies. The frameworks are easy and very important when working in a large and quickly changing code base.

2 | Have one project that shows EVERYTHING off

This is also a pretty intuitive point. Most technical interviewers are going to ask you to dive into a project, be it personal or professional. When you do this, your goal should be to demonstrate to them that you:

Are familiar with all (or at least most) of the elements in the interviewer's company stack
Are thoughtful and meticulous when it comes to planning
Are competent at implementation
Can solve problems effectively as they appear
Are passionate about software development

It's especially important that, with whatever project you pick, you are able to discuss at least one significant challenge that came up which you were able to overcome. This problem should be a topic you can talk about in depth. It may be helpful to frame this in the following context:

What was the problem?
How did you approach solving it?
What tradeoffs existed with your solution, if any?
Was your solution successful?

When determining which project you plan to show off, definitely lean toward projects you genuinely enjoyed — your interest and passion for the work will likely come across in the interview (that's a good thing).

3 | Study up on common technical interview questions

You will likely receive at least one stage of technical evaluation, so be prepared! Here are some great resources for practicing some of the common technical interview questions:

Practice with friends and family until you have these answers down. There are plenty more resources out there, so lean on Google to find more!

I'd also recommend you not only drill common questions, but practice code challenges on a website like LeetCode or CodeWars.

The big takeaway here is: come prepared to talk technical theory. Know those "must-know" interview questions (eg. "What is an array?"), but also be ready to answer questions you've never seen before. Software engineering is problem solving at its core, so make sure you're ready to flex your problem solving muscles 💪

4 | Assemble a neat resume, a portfolio on your own hosted website, and polish your resume, as well as your GitHub

For many interviewers, one’s resume, portfolio, LinkedIn, and GitHub go a long way in forming the initial impression of a candidate. Make sure each of these mediums are polished and squeaky clean. Don’t give reviewers a reason to cross you off the list of candidates before you get the chance to chat in-person. The following resources can help you ensure you leave a good impression on paper:

5 | Find a mentor with whom you can simulate a practice interview

If you haven’t already, try to find a mentor software engineer who would be willing to give you a couple hours of their time to sit down with you on a video call and simulate a technical interview.

I was fortunate enough to know several developers when I got started in the software space. One of them, a good friend of mine, spent a couple hours one day just drilling me on technical questions using screen-share on a Google Hangout. This can be really useful, especially when it comes to getting the pre-interview jitters out of the way!

A mentor is also a great resource for feedback. Try asking them for input on your resume, portfolio, LinkedIn, and GitHub account — they might just spot an issue that can be a red flag for an interviewer 👀

6 | Connect with a reputable recruiting firm

Recruiting firms are a fantastic way to connect with businesses offering positions that are well aligned with your skill set and stack. There are many of them out there and each has a unique process for how they vet candidates and onboard them into their various candidate pools (typically organized by tech stack). You can connect with these firms in a few different ways.

LinkedIn can be a quick and easy tool to get a dialogue started with recruiters. Just open up your Profile on your LinkedIn and click the Open to button and then select the Finding a new job option. This should let recruiters in your area know you are happy to chat. Then just stay on top of your LinkedIn messenger and wait for recruiter outreach to begin.
Reach out directly. There are plenty of recruiting firms out there, many of whom are becoming more flexible geographically with remote work options increasing. Most of these have some kind of resume submission portal through which you can send a CV. I've worked with Motion Recruitment before, formerly "Workbridge Associates," in the greater Boston area and they were great 👍

When you begin chatting with recruiters, ensure you research their firm's reputation on their website and GlassDoor. Also, be sure to only consider firms that do not take a cut from your salary as a fee — there are plenty of them that earn a head hunter fee from the businesses posting the open positions, those are the ones you should try to work with.

Also, I'd recommend being open to allowing their firm rep that you work with negotiate on your behalf once you have possible job offerings in the pipeline. More often than not, these reps can increase your job offer as they are typically the liaisons between you and the client company. What's great is their interests are aligned with yours, so the more money you make, the more money they’ll make as well - everybody wins! 💰

7 | Be ready to fail, but remain persistent and passionate

Like anything worth doing, failure is a probability, especially across the first few interviews. Be ready to fail, and be ready to learn from your failures.

Interviewing is a skill like anything else, so long as you are genuinely prepared and are applying yourself, the more reps you get, the higher your chance of a successful outcome

Software Engineering is a fantastic field with tons of exciting opportunities, however, it’s not for everyone. It can be cognitively intensive and very fast moving, forcing you to learn always. If you’re not passionate about or compelled to build software, it’s probably not worth investing your time and effort searching for a job in the space. Only do it if you love it.

Thanks for Reading

That's it! I hope these tips are helpful in your pursuit to lock down your first developer job. With dedication and persistence, any knowledgeable engineer should be able to find a position at a company to which they can effectively contribute. You can do it! 💪