SEEK Bytes

Ever shipped a “simple” feature and discovered your date/time logic is on fire? In this episode of SEEK Bytes, the crew dive into the weird, wonderful and truly painful world of time zones, UTC and daylight savings – and why getting this wrong can break products, reports and disaster recovery plans across your whole IT stack.

In this episode, we explore:

• Why time zones are way messier than you think – odd offsets, countries changing time zones overnight, multiple names for the same UTC offset, and scenarios where two people standing on the same street literally disagree on what time it is.

• How this breaks real-world systems – from expiring promo links and DR runbooks to global products that must store bookings across APAC and beyond, plus the UI pain of showing “the right” local time vs relative time for each user.

• Survival tips for developers – why standards bodies say “just store UTC + offset”, when to lean on libraries like NodaTime instead of native date objects, and how epoch timestamps, ISO 8601 formats and good packages can save you from reinventing the world’s worst wheel.

Whether you’re in software engineering, data, SRE, ops, security or any IT role that touches logs, reports, alerts or user-facing dates, this episode will change how you think about time – and probably make you a lot more cautious the next time someone says “it’s just a datetime field”.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Remote work is here to stay – but distributed teams are a whole different game. In this episode of SEEK Bytes, Elliott, William Lark, Laavanya Kathiresen and Jerome Chan unpack how SEEK runs truly APAC-wide tech teams across Australia, New Zealand and Malaysia – without falling into “us vs them”.

This episode's special guests: Laavanya Kathiresen (SEEK Engineering Director, Candidate) and Jerome Chan (SEEK Head of Engineering, Profile & Apply)

In this episode, we explore:

• Remote vs distributed: what’s the real difference? – why “remote” is about how individuals work, while “distributed” is an organisational discipline around ways of working, agreements and processes across locations.

• How SEEK makes distributed teams actually work – setting core hours, protecting “sacred” lunch time, keeping calendars and Slack statuses up to date, using Zoom-only meetings with cameras on, and designing async done right so people stay in flow instead of drowning in Slack.

• The upside: careers, diversity and global coverage – how distributed ways of working unlock roles across Melbourne, KL, Auckland and beyond, widen the talent pool, bring richer cultural perspectives into problem-solving, and even keep the lights on when one country’s on a public holiday.

Whether you’re a software engineer, SRE, BA, PM, people leader or IT manager trying to make hybrid/distributed work actually work, this episode is packed with real tactics from teams who ship across time zones every day – without losing culture, connection or careers.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode

What does it feel like to help run a three-year, hundreds-of-millions-of-dollars unification project that merges three tech companies, dozens of systems and thousands of people – and then still keep the job boards running every day? In this episode of SEEK Bytes, CTO James Ross returns to share the unfiltered story of SEEK’s APAC unification, why he compares it to a “house renovation you love but never want to do again”, and what engineers can learn from it about scope, time and careers.

This episode's special guest: James Ross (SEEK CTO)

In this episode, we explore:

• How SEEK pulled off unification without burning everything down – migrating three companies’ worth of platforms, mobile apps, finance systems, CRM and collaboration tools, running 40-hour cutover weekends with 300–500-step runbooks, and using huge manual UAT “rocket gantries” to make sure it all worked exactly once.

• How to “dance inside the triangle” of time, cost and scope – why unification optimised ruthlessly for time, how product managers managed relentless scope trade-offs (including things like annual vs monthly salaries across markets), and why context-driven decisions beat one-size-fits-all best practices.

• Real talk on moving from engineer to CTO – James’ journey from clean-code-obsessed programmer to CTO, why most engineers would hate his job, how feedback loops shrink from “red-green-refactor” speed to “psychiatry-level” slowness in management, and how to know if you’re better suited to the leadership track or deep IC/lead engineer path.

If you’re in software, data, infrastructure, SRE, product, support or IT leadership and you loved Part 1 – or you just want the unfiltered truth about huge platform migrations, trade-offs and tech careers at the top – this Part 2 is packed with hard-won lessons you can apply in your own org.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode

What does it really take to merge multiple tech companies, migrate millions of users and jobs, and come out stronger – with zero engineering layoffs? In this episode of SEEK Bytes, hosts Raph, Seamus and Elliott sit down with SEEK’s CTO James Ross to unpack the massive Unification program, why it was worth hundreds of millions of dollars, why it had to be a big-bang cutover, and why the hardest problems were never just technical.

This episode's special guest: James Ross (SEEK CTO)

In this episode, we explore:

• Why Unification was truly “transformative” – how SEEK turned multiple regional winners (SEEK, JobStreet, JobsDB and more) into a single employment marketplace, so every new feature is built once and shipped to 430M+ people across APAC, instead of re-implementing it five times.

• How you even plan a project like this – choosing the modern ANZ stack as the unified platform, deciding to optimise ruthlessly for time over cost and scope, avoiding “impossible” two-way sync by streaming data one-way for months, and running high-stakes cutover weekends where there was literally no going back.

• Why people and culture made or broke it – no engineering layoffs, moving Asia engineers onto the new stack 18 months early, navigating cross-cultural friction (like Australians’ hyper-egalitarian style), and using meaning, progress and repeated “why” storytelling to keep thousands of people aligned on a multi-year bet.

If you work in software engineering, data, infrastructure, SRE, architecture, product or IT leadership, this is a rare, candid look at what a real, high-stakes tech transformation looks like – technically, organisationally and culturally – from someone who’s been doing it for nearly 40 years.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode

The toughest lessons in tech don’t come from tutorials – they come from mistakes, awkward feedback and a few bruised egos. In this episode of SEEK Bytes, Will, Raf and Seamus unpack the career lessons they (and others) learned the hard way – from code reviews and clean-code obsession to social anxiety, failure and adapting to very different managers.

In this episode, we explore:

• How to have impact beyond “clean code” – why endlessly refactoring or converting 40+ files to TypeScript isn’t the career accelerator you think, and how focusing on team outcomes, delivery and business value gets noticed far more than that perfect mapping function.

• How to grow through mentoring, feedback and failure – the difference between teaching, mentoring and coaching, how to be a great grad buddy, why radical candor is about vulnerability (not cruelty), and how embracing failure, bad ideas and honest feedback can super-charge your growth.

• Navigating managers, anxiety and influence at work – adapting to different management styles (including micromanagers), servant leadership in practice, dealing with the “spotlight effect” and harsh-sounding emails, and why relationships and trust matter more than perfectly-worded Slack messages when you want to influence upwards and across.

If you’re in software engineering, data, infrastructure, support, product or IT leadership, this episode is a playbook of real-world lessons you can steal – so you don’t have to learn all of them the hard way yourself.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Constant pings. Back-to-back meetings. 600 Slack channels. If your day in IT feels like pure context-switch chaos, this episode of SEEK Bytes is for you. Will, Raf and Elliott break down the biggest productivity killers in modern tech work – and how to reclaim real focus time without blowing up your team culture.

In this episode, we explore:

• The real productivity killers in tech – Slack overload, endless alerts from tools like Datadog, Snyk, Renovate and PagerDuty, too much work-in-progress, and why “single-threaded humans” always pay the cost of multitasking and constant interruptions.

• Deep work, focus time and flow days – using personal Kanban WIP limits, focus blocks, meeting-free “flow days” and time-of-day hacks (early mornings, late evenings) to carve out real maker time in meeting-heavy environments.

• Kanban, pull systems and The Phoenix Project – how treating IT like a production line helps you see bottlenecks, why pull-based work beats “just keep adding more”, and how too much WIP quietly turns every sprint into waterfall.

• Surviving meetings, information overload and burnout – practical tactics for saying no, delegating, note-taking that actually sticks, managers protecting team time, clean end-of-day commits, and knowing when to call it and come back fresh tomorrow.

Whether you’re a software engineer, SRE, BA, sysadmin, tech lead or IT manager, this episode will help you spot what’s silently draining your focus – and give you concrete ideas to rebuild a healthier, more productive workday.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Think senior engineers know every answer, ship only shiny greenfield projects and never get laid off? Think again. In this episode of SEEK Bytes, Will, Raf and Elliott dive into the biggest myths juniors (and even mid-career folks) believe about becoming “senior” – and what growth in tech actually looks like in the real world.

In this episode, we explore:

• What being “senior” actually looks like day to day – why the title alone is meaningless, how real seniors stay calm in uncertainty, ask better questions and know how to debug unknowns, and why even staff engineers still feel like juniors sometimes (and absolutely still break prod).

• Myths vs reality of senior perks – seniors often care for legacy systems while juniors play with shiny greenfield work, still do “boring” tasks like AWS tagging and documentation, juggle more meetings and stakeholders, and are not magically safe from layoffs or burnout.

• Healthier ways to grow your career at any level – how to push for technical change without “throwing your weight around,” use code reviews and documentation as learning superpowers, challenge the status quo (even as a grad), build trust with your team, and see failure and feedback as fuel instead of threats.

If you’re a student, junior dev, career-switcher or seasoned IT pro wondering what “senior” really means – and how to grow without burning out – this episode is packed with honest stories, practical mindset shifts and permission to build a career that actually fits your life.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Your app ships on the shoulders of strangers’ code – and one tiny NPM package can bring production to its knees. In this SEEK Bytes MixBytes episode, Seamus and Raf unpack the wild world of NPM incidents, AI-powered tooling and imposter syndrome, and what they all mean for anyone working in modern IT.

In this episode, we explore:

• How fragile our dependency stacks really are – the story behind LeftPad and why NPM banned unpublishing, the “everything” package that created an immovable dependency ball, and real protestware incidents in Faker.js, color.js and node-ipc that leaked into tools like Vue CLI.

• Practical dependency hygiene for real teams – pinning vs ranges, SemVer myths, why a “patch” can still break prod, using tools like Renovate and Dependabot, and why being a good package maintainer is its own specialist skill – especially when millions of systems rely on your code.

• TypeChat, cognitive load & imposter syndrome – how Microsoft’s TypeChat can bolt LLMs onto existing apps with strongly typed payloads, why inheritance, over-factoring and shallow microservices crush your brain, and how SEEK’s pairing culture, radical candor and “barrel vs bullets” mindset help devs navigate imposter syndrome.

Whether you’re in software engineering, DevOps, security, data or IT leadership, this episode gives you war stories, guardrails and mindset shifts for working safely with open source, integrating AI into real systems, and staying sane in a fast-moving industry.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Your JavaScript is running – but is your runtime doing you any favours on speed, security and cost? In this episode of SEEK Bytes, Seamus, Will and Rahul unpack the fast-moving world of JavaScript runtimes and engines – from Node.js and V8 to up-and-comers like Deno and Bun – and what they mean for teams running real systems in production.

In this episode, we explore:

• What a JavaScript runtime actually is (vs an engine) – a sandboxed environment that provides I/O, env vars and APIs, on top of engines like V8 or JavaScriptCore that parse and execute your code, plus why Node, browsers and tools like ts-node all sit on this stack differently.

• How modern runtimes reshape DX, security and performance – from Deno’s --allow-net / --allow-read-style permissions and URL-based imports, to Node 18’s built-in test runner, to Bun bundling JSX, TypeScript, formatting and tooling so you’re not hand-wiring ESLint, Prettier and watch modes every time.

• Why competition (Node vs Deno vs Bun) is good for everyone – how claims like “performance-focused” and “drop-in Node replacement” sparked spicy benchmark debates, pushed Node to mature, and give engineers real choices for hackathons vs production systems in a TypeScript-everywhere world.

Whether you’re a software engineer, SRE, architect, DevOps, platform or IT manager, this episode will help you make smarter choices about the JavaScript under your products, dashboards and devices – and understand where the ecosystem is heading next.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Internal platforms, CI/CD pipelines, GraphQL gateways, job search APIs – the hidden tools behind every product release. In this episode of SEEK Bytes, Seamus, Bridget, Nik and Reyna go deep on developer tooling done right: treating engineers as real customers, scaling support without burning out, and knowing when it’s finally time to turn a beloved tool off.

In this episode, we explore:

• How to treat engineers as real customers – using pairing, one-on-one interviews, surveys, PR metrics and “apathy as a signal” to understand how teams actually use your platform, where they struggle, and what “easy to contribute” really looks like for something like SEEK’s GraphQL layer.

• How to scale support and adoption without burning out – from guinea-pig teams and training classes to champions embedded in product squads, dedicated Slack support channels, docs-as-part-of-your-MVP, FAQs built from repeated questions and the dream where your community answers most questions before you even see them.

• When (and how) to sunset a tool – the story of SEEK’s SQS Move utility being replaced by native AWS features, announcing deprecations, brownouts, injecting latency to “see who screams”, handing ownership to the last remaining team and navigating the politics and emotions of telling people their favourite tool has to die.

If you’re in platform engineering, SRE, DevOps, data, API or general IT and care about developer experience, incident risk and getting more value from the tools behind your stack, this episode will give you practical patterns you can steal for your own org.

🔔 Follow the SEEK Bytes podcast so you never miss a new episode