SEEK Bytes

OpenClaw: Build your own AI Agent workforce (without getting burnt)

Tue, 12 May 2026 15:00:00 -0000

What if you could spin up a whole AI workforce on your own machine – planners, “engineers”, researchers and content creators – and run it all from a simple chat window? In this episode of SEEK Bytes, we explore OpenClaw, the agent platform that lets you act like the CEO while AI agents do the grunt work in the background. In this episode you’ll learn: • How OpenClaw turns AI into a digital team – using one “front-of-house” bot as your main interface, then spinning up specialised agents behind the scenes to research, draft content, update tickets and even prepare changes for real systems. • What it really costs to run this at home – from beefy GPUs and Mac minis to cloud API bills that can quietly blow past a few hundred dollars a month, plus why some “cheap and easy” YouTube setups gloss over the real price tag. • The security & scam risks you need to know about – including AI “app” stores where around 1 in 5 skills are malicious, how the wrong plugin can leak your data or crypto, and why doing your homework before you plug AI into your systems is non-negotiable. Drop a comment if you’ve tried building your own AI stack (or are tempted to), and hit Subscribe for more real-world AI, security and engineering stories from the SEEK Bytes team. 🔔 Follow SEEK Bytes podcast so you never miss a new episode

NX Supply Chain Attack Explained (with Trevor Kilvington)

Tue, 05 May 2026 15:00:00 -0000

Imagine updating a trusted monorepo tool… and the next time you open your terminal it asks for your password, then tries to shut your machine down. In this episode of SEEK Bytes, Will, Seamus and SEEK Staff Engineer Trevor Kilvington unpack the NX supply chain attacks – how they unfolded, why they were so scary, and what every IT team can learn from them. This episode's special guest: Trevor Kilvington (SEEK Staff Engineer) In this episode, we explore: • How a popular open-source tool ended up shipping malicious code to developers’ laptops and CI pipelines – and how SEEK engineers helped spot it first • Why attackers leaned on AI prompts and worm-like behaviour to hunt for secrets and quietly spread through NPM packages • The uncomfortable question of whether keeping everything “always up to date” is still the safest choice – and what this means for CI/CD ownership and developer responsibilities Whether you’re in software engineering, DevOps, SRE, security, platform or IT leadership, this episode will change how you think about package updates, build pipelines and the tools you trust every day. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

Inside SEEK’s Legendary Hackathons (with Glenn Wilson, Kat Vassallo & Andy Maxey)

Tue, 28 Apr 2026 15:00:00 -0000

This episode of SEEK Bytes steps away from code to celebrate one of SEEK’s most loved traditions: Hackathon. Will is joined by Kat, Andy and Glenn to lift the lid on how a twice-yearly, three-day event brings together people from every corner of SEEK to dream up bold ideas – many of which end up on real roadmaps and in front of real customers. In this episode you’ll learn: This episode of SEEK Bytes – a podcast for engineers by engineers – steps away from code to celebrate one of SEEK’s most loved traditions: Hackathon. Will is joined by Kat, Andy and Glenn to lift the lid on how a twice-yearly, three-day event brings together people from every corner of SEEK to dream up bold ideas – many of which end up on real roadmaps and in front of real customers. This episode's special guests: Glenn Wilson (Snr Business Analyst / former Community Engagement Lead), Kat Vassallo (Tecnology Community Engagement & Innovation Manager), Andy Maxey (EVP & Community Impact Lead) In this episode you’ll learn: • How SEEK hackathons actually work – three days off BAU, 40+ teams hacking across APAC, big themes (from space operas to dinosaurs), t-shirts as badges of honour and a Shark Tank-style final where the ELT judges every idea. • Why hack is core to SEEK’s culture and EVP – how grassroots volunteers, wild costumes, candy bars and chaos create a safe space for experimentation, help people work with teams they’d never normally meet, and generate ideas that influence products, processes and even board-level conversations. • How any company can start their own hackathon – practical tips on beginning with a half-day or single-department event, proving value before going company-wide, getting leadership buy-in, and using hackathons to build skills, networks and long-term innovation habits. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Human vs AI: The Sleep-Deprived Dev Who Beat OpenAI’s Code Bot

Tue, 21 Apr 2026 15:00:00 -0000

An OpenAI-backed coding agent. 12 elite competitive programmers flown to Tokyo. A 10-hour marathon solving an NP-hard puzzle in front of a live stream. And a very sleep-deprived human still manages to beat the AI at its own game. In this episode of SEEK Bytes, Elliott Millar, Will, Seamus and Arnav break down the World Tour Finals heuristic contest where a human edged out a custom AI built just for competitive coding. In this episode, we explore: • How the competition was set up so both humans and a custom OpenAI agent had to race the same brutally hard optimisation problem under tight time limits • The surprisingly simple strategy a sleep-deprived engineer used to out-score a specialised AI model • What we can learn from how the AI iterated, refactored and “thought” about code during the contest • Why the story might change when you put the human’s winning code back into the AI – and what that says about humans + AI working together Whether you’re in software engineering, data, SRE, platforms, security or any IT role wondering how far AI coding tools can really go – and where humans still have the edge – this episode is a fast-paced, deeply nerdy look at the future of competitive problem solving and day-to-day development with AI in the loop. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

Axios Hack - A SEEK Bytes Special Episode (with Eldar Marcussen)

Thu, 09 Apr 2026 11:30:00 -0000

This is a special SEEK Bytes drop – outside the regular Season 3 line-up – because the recent Axios NPM hack is too important to ignore. In this episode of SEEK Bytes the crew sit down with Eldar Marcussen from SEEK’s offensive security team to unpack what actually happened, why supply-chain attacks are so scary, and what you should do today to reduce your risk. In this episode you’ll learn: • What a supply-chain attack really is – how a single malicious dependency in a trusted package like Axios can silently run on thousands of machines, and why closed-source software isn’t magically safer. • What to do if you think you’ve been hit – practical first moves for companies and individuals: rotating keys, rebuilding or containerising machines, reviewing logs, and knowing when to call in your security team. • How to raise the bar for attackers – simple habits like pinning and ageing dependencies, using tools like Docker and alternative package managers, relying on built-in protection like Windows Defender, and staying alert to sketchy extensions and “too good to be true” downloads. 🔔 Follow so you don’t miss future special drops like this – plus our regular Season 3 episodes every week.

SEEK Bytes returns on April 22 for Season 3

Sat, 04 Apr 2026 02:46:00 -0000

SEEK Bytes is back for Season 3 on 22 April, and we’re turning things up a notch with a major focus on AI of course. This season dives into the real world of working in tech today – from AI reshaping how we build and secure systems, to the culture, careers and decisions that make or break modern engineering teams. Whether you’re a seasoned developer, just starting out in IT, or simply curious about how technology is changing work, Season 3 brings you sharp, honest conversations straight from the engineers, designers and security experts living it every day. 👍 Hit Follow so you don't miss a new episode and don't forget to check out past episodes if you haven't already.

From Engineer to EM: Imposter Syndrome, Mentors & more (with Gladys Lim)

Mon, 05 May 2025 22:42:00 -0000

Thinking about moving from hands-on coding to people leadership – or just wanting more control over your engineering career? In this episode of SEEK Bytes, we sit down with Gladys Lim, an Engineering Manager based in Kuala Lumpar who leads squads in SEEK’s monetisation & insights domain, building products that keep hirers coming back This episode's special guest: Gladys Lim (SEEK Engineering Manager - based in Kuala Lumpur) Gladys shares her journey from barcode integrations and games dev to full-stack engineer and, eventually, EM – including what surprised her about loving people leadership, how she navigated a jarring feedback-loop shift, and why management is a different career path, not just a promotion. She gets real about imposter syndrome, being a woman in tech across APAC, hiring for diverse teams, and using empathy, vulnerability and structure to make mentoring actually work. In this episode you’ll learn: • What it really means to shift from IC to EM – from instant code feedback to months-long people outcomes, delegating without micromanaging, and redefining success as enabling the team, not being the strongest coder. • How to navigate imposter syndrome and bias – using facts to reframe negative self-talk, turning comparison into learning, and creating inclusive rituals so quieter and under-represented voices are actually heard. • How to take charge of your career and mentorship – clarifying your motivations, choosing between IC and leadership paths, saying “no” when the fit or timing is wrong, and designing mentoring relationships that serve your specific growth goals. If you’re a software engineer, data/IT professional, team lead or aspiring manager wondering whether people leadership is for you – or how to better support the EMs you work with – this episode is packed with honest stories, practical tactics and career advice you can apply today. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

Clean Architecture in Practice (Part 2): Entities, Gateways & more (with Adam Kreitals)

Tue, 22 Apr 2025 15:00:00 -0000

Heard of “clean architecture” but not sure what it looks like in real code? In this episode of SEEK Bytes, Seamus, Will and Adam Kreidels (Head of Engineering, Monetisation & Insights at SEEK) are back for Part 2 of their deep dive – unpacking entities, use cases, gateways, the dependency rule and the famous “onion” diagram in a way any IT pro can apply. This episode's special guest: Adam Kreitals (SEEK Head of Engineering, Monetisation & Insights) In this episode, we explore: • Why “start with the database” slows you down – and how leading with business rules and use cases speeds up delivery. • How entities, use cases and gateways work together – using price, order and discount examples from SEEK to show clean seams between domain and tech. • How clean architecture reduces the cost of change – what good separation of concerns looks like in code, and how to spot when frameworks and APIs are leaking into your core domain. If you’re a software engineer, tech lead, architect, SRE, platform engineer or IT manager who wants code that survives framework swaps, org changes and new requirements – and you liked Part 1 – this Part 2 episode gives you the concrete concepts, terminology and mental models to put clean architecture into practice. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

Clean Architecture 101: Future- Proofing Code, Teams & more (with Adam Kreitals)

Tue, 15 Apr 2025 15:00:00 -0000

Ever wondered what a technical product manager actually does – and why every modern tech org seems to want one? In this episode of SEEK Bytes, Will is joined by Leon Belobrov and Alex Stewart-James to unpack how SEEK builds platform products that power everything from candidate apps to internal tooling – and what it means to be a PM for APIs instead of UIs. This episode's special guests: Leon Belobrov (SEEK Principal Product Manager, Platform) and Alex Stewart-James (SEEK Snr Technical Product Manager) They break down what makes TPMs a bit of a “unicorn role” – blending deep product thinking with enough technical context to serve engineers as their primary customers – and why internal platforms, APIs and deployment pipelines are becoming just as important as customer-facing apps. You’ll hear how SEEK uses jobs-to-be-done research with engineers, metrics like time-to-10th PR, and platform reliability/security KPIs to prioritise what gets built – and what gets cut. In this episode you’ll learn: • The real difference between a “regular” PM and a TPM – including why serving engineers, focusing on APIs and reusable capabilities, and obsessing over platform reliability changes how you think about product. • How SEEK discovers what engineers actually need – from interviewing 25+ engineers across the business to mapping their pain points into jobs-to-be-done and opportunity scores, instead of just building what the loudest voice wants. • Practical advice if you want to move into TPM or work better with platforms – including dogfooding, avoiding over-engineering, and remembering that “you are not your customer” even when you’re an engineer building for engineers. If you’re a software engineer, platform/DevOps engineer, BA, product manager or IT leader curious about platform teams, internal products and where technical PMs fit into modern tech orgs, this episode gives you a front-row view into how SEEK does it – and how you might shape a similar path. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

$50K at 15: Zendesk Bug Bounty Drama, White Hats & Weak Links

Tue, 08 Apr 2025 15:00:00 -0000

What happens when a 15-year-old hacker quietly discovers a single bug that touches over half of the Fortune 500, chains it into a Slack takeover, and walks away with $50K in bug bounties – only for the original vendor to refuse to pay? In this episode of SEEK Bytes, we break down Daniel’s Zendesk exploit, the ethics of disclosure, and what “white hat” really means in practice. We unpack how a “basic” support inbox (support@company.com), misconfigured SSO and email spoofing turned into a way to join internal tickets, steal Slack access and read sensitive conversations – all via a third-party tool many enterprises barely think about. We also dig into how bug bounty programs work, why Zendesk’s scope call sparked controversy, and how SEEK runs security exercises to stay ahead of attackers. In this episode you’ll learn: • How the exploit actually worked end-to-end – from Zendesk ticket IDs and CC’ing yourself onto “internal” threads, to chaining Apple/Google OAuth and Slack login for access to private workspaces. • Why the bug bounty outcome was so controversial – how email-spoofing being “out of scope” left Daniel unpaid by Zendesk, and what this means for incentivising white-hat behaviour vs pushing hackers towards greyer choices. • Practical security takeaways for engineers – the real risk of “weakest link” third-party tools, why internal channels are goldmines for social engineers, and how separation of concerns and well-designed bounties can protect both your systems and your customers. Whether you’re in software engineering, security, cloud, support, architecture or IT leadership, this episode is a gripping case study in modern attack chains, bug bounty programs and why “it’s just email” or “it’s just a ticketing tool” is never the whole story. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

Technical PM (Part 2), Platforms & Careers (with Leon Belebrov and Alex Stewart-James)

Tue, 01 Apr 2025 14:00:00 -0000

What if your next big career move in tech wasn’t into management or staff engineering – but into technical product management? In this episode of SEEK Bytes, Will continues the conversation with Leon Belobrov and Alex Stewart-James in Part 2 of our deep dive into technical PMs, platform teams and how engineers can shape the roadmap (and their careers). This episode's special guests: Leon Belobrov (SEEK Principal Product Manager, Platform) and Alex Stewart-James (SEEK Snr Technical Product Manager) They share how interviewing dozens of SEEK engineers surfaced honest feedback, surprisingly clear asks, and a long list of “we just built it ourselves” tools that should really be platform products – plus why removing features and legacy tools can be just as valuable as shipping new ones. You’ll also hear what it takes to move from senior engineer or BA into a TPM role, and why this space is still early enough to shape if you jump in now. In this episode, we explore: • How engineers can influence the technical roadmap – from being a “demanding customer” to joining product discussions, speaking the language of metrics, and tying tech work to business outcomes. • When to invest in platform teams (and how to get buy-in) – spotting the point where every squad is solving the same non-differentiating problems, and making the case for centralising capabilities like security and infra. • How to grow into a technical product manager – mapping your existing skills, building a portfolio of real communication and customer-empathy stories, and becoming a true platform evangelist who can win funding and adoption If you’re a software engineer, SRE, BA, platform/DevOps engineer, product manager or IT leader curious about owning internal platforms, shaping developer experience or shifting into technical product roles, this Part 2 conversation is packed with practical advice, career angles and real-world stories you can apply right now. If you’re a software engineer, SRE, BA, platform/DevOps engineer, product manager or IT leader curious about owning internal platforms, shaping developer experience or shifting into technical product roles, this Part 2 conversation is packed with practical advice, career angles and real-world stories you can apply right now. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

What Is a Technical Product Manager? (with Leon Belebrov and Alex Stewart-James)

Tue, 25 Mar 2025 14:00:00 -0000

Ever wondered what a technical product manager actually does – and why every modern tech org seems to want one? In this episode of SEEK Bytes, Will is joined by Leon Belobrov and Alex Stewart-James to unpack how SEEK builds platform products that power everything from candidate apps to internal tooling – and what it means to be a PM for APIs instead of UIs. This episode's special guests: Leon Belobrov (SEEK Principal Product Manager, Platform) and Alex Stewart-James (SEEK Snr Technical Product Manager) In this episode, we explore: • What platform engineering and technical PMs actually are – internal platforms as products for engineers, boosting delivery velocity and reducing cognitive load across infra, CI/CD, observability and security, plus why platform PMs are a “unicorn” blend of product skills and deep technical understanding. • Technical PM vs “regular” PM – shared foundations (customer value, business outcomes, strategy alignment, success metrics) and key differences when your “UI” is APIs, pipelines and DevDocs rather than screens – including jobs-to-be-done research with engineers and metrics like uptime, security posture and time-to-10th PR. • Designing platforms engineers actually want to use – jobs-to-be-done studies across SEEK, turning 25+ “jobs” into prioritised opportunity scores, tackling notorious pain points like scattered documentation and fragmented health monitoring, and avoiding traps like over-building for a single vocal team or assuming “I’m an engineer, so I know what they need”. • DevOps, cognitive load and minimum viable platforms – how platform thinking evolved alongside DevOps, shifting security and observability “left” without dumping everything on product teams, and finding the balance between sensible defaults, transparency and not turning platform teams into bottlenecks. • Careers and skills for aspiring technical PMs – why you don’t need to be the strongest coder in the room, how to lean on engineering partners while bringing customer/strategy thinking, and the unique advantage of having your “customers” (engineers) sitting right next to you for fast feedback and constant dogfooding. If you’re a software engineer, SRE, platform/DevOps engineer, BA, product manager or IT leader curious about platform teams, internal products and where technical PMs fit into modern tech orgs, this episode gives you a front-row view into how SEEK does it – and how you might shape a similar path. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

Deepfakes, Casino Hacks & SIM Swaps: Security scares (with Kelsy Luengen)

Mon, 17 Mar 2025 18:59:00 -0000

AI-generated voices, fake bosses on Zoom, SIM-swapped phones and a casino shut down from a single service-desk call – this is what modern cybercrime really looks like. In this episode of SEEK Bytes, Elliott Millar, Will and security influencer Kelsey Lundgren return for Part 2 to dig into the latest social-engineering threats, AI-powered scams and why shame keeps attacks hidden. This episode's special guest: Kelsy Luengen (SEEK Security Influencer) Kelsey unpacks why hackers hack, how shame and under-reporting keep crime in the dark, and the terrifying rise of AI-driven social engineering – from MGM’s casino shutdown to employment and romance scams, deepfake Zoom CEOs, voice-cloned “your child’s in trouble” calls, and malicious “ChatGPT” apps that are really just malware with great branding. She also shares how SEEK builds a no-blame security culture, why she’d rather you over-report “weird” emails, and how to talk about scams with colleagues, customers and your own family without making anyone feel stupid. In this episode you’ll learn: • How modern scams really work – and why smart people still fall for them – including the psychology of shame, under-reported romance and job scams, and how a single phone call socially engineered a casino into chaos. • How AI is super-charging attackers – from flawless phishing copy and personalised recon to deepfake voices and faces, malicious “AI” downloads and even tricking chatbots into generating attack templates under the guise of “training”. • Practical ways to protect yourself, your team and your family – why app-based 2FA beats SMS, what SIM swapping is, how to sanity-check QR codes and “AI tools”, using family codewords, and how leaders can build a culture where people report near-misses instead of hiding them. If you’re in software, data, support, security, product or IT leadership, this Part 2 episode will sharpen how you think about human-layer risk, AI-driven threats and the culture you need so people actually report problems before they become incidents. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

Security Influencer, Phishing & DnD Training (with Kelsy Luengen)

Tue, 11 Mar 2025 14:00:00 -0000

Think your biggest security risks are zero-days and fancy exploits? In this episode of SEEK Bytes, Elliott, Will and criminologist-turned-security-influencer Kelsy Luengen unpack why humans – not tech – are still the easiest way into your systems, and how SEEK is using crime theory, data and even Dungeons & Dragons-style games to fight back. This episode's special guest: Kelsy Luengen (SEEK Security Influencer) Kelsey explains the full phishing family – email, SMS, QR “quishing”, phone scams, spear-phishing and whaling – and walks through how she turns SEEK engineers into “hackers” using Dungeons & Dragons-style games, escape rooms and level-five difficulty phishing simulations to make training fun, not finger-waggy. She also shares why a report-phishing button alone doesn’t change behaviour, what actually moves the needle, and how engineers can partner with security early so features don’t become social-engineering goldmines later on. In this episode you’ll learn: • How modern phishing really works (and why tech people still fall for it) – from fear-based emails and boss-impersonation to targeted attacks built from LinkedIn posts, podcasts and public data. • Why “awareness” isn’t enough – the limits of simple nudges and buttons, and how SEEK uses behaviour-changing experiences, metrics and relationships to build a lasting security culture. • What engineers can do today to level up security – thinking “crime prevention” in your designs, knowing when to call in security, and how a strong partnership lets you ship faster and safer. If you’re in software engineering, data, product, support, SRE, security or IT leadership, this episode will change how you think about security culture – and give you ideas for making secure behaviour stick in your team without boring slide decks and tick-box training. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

Airport Security Hacked? SQL Injection, Flight Risk & Interview Red Flags

Tue, 04 Mar 2025 14:00:00 -0000

An airline cockpit access system vulnerable to a single quote in a login box. White-hat hackers quietly holding an entire flight database. And tech interviews that feel more like interrogations than conversations. In this SEEK Bytes episode, the crew dig deeper into real-world security failures and then we pivot into raw, honest engineering interview horror stories and practical tips for staying human and effective under pressure. In this episode, we explore: • How a real airline security system got hacked via SQL injection – and why exposing raw SQL errors, skipping extra checks and trusting third parties blindly can be so dangerous. • The basics of SQL injection and how to defend against it – in plain language, with examples of string concatenation gone wrong, parameterised queries done right, and the top attack types every engineer should know. • What good (and bad) tech interviews look like in practice – red flags to run from, how to manage “exam panic”, and why being human, curious and clear about your gaps can still set you apart. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

How SEEK Ships Frontends (Pt 2): Platforms, SSR & more (with Jahred Hope)

Tue, 25 Feb 2025 14:00:00 -0000

How do you run dozens of React apps, keep dependencies sane, preview any branch on any environment – and still move fast without breaking prod? In Part 2 of our frontend deep dive, Elliott Millar, Will and Jared Hope (Engineering Manager, Frontend Practices at SEEK) go beyond components to explore platforms, tooling and practices that power SEEK’s web experience at scale. This episode's special guest: Jared Hope (SEEK Engineering Manager, Frontend Practices) In this episode (Part 2), we explore: • How SEEK turns frontend into an “experience platform” – from modeling the web platform, static site generation and UI versioning, to giving teams self-serve routing and deployments on top of Cloudflare and serverless. • The tools that supercharge DX and design collaboration – including SEEK’s internal deploy tooling, environment-per-branch previews, and Playroom, which lets engineers and designers prototype in real components and share ideas with a single URL. • How SEEK keeps frontend modern at scale – using Upkeep and Renovate to tame dependency sprawl, exploring SSR and React server components without losing SSG DX, and leaning on devtools, hot reload and consoles for fast, pragmatic debugging. If you’re a frontend or full-stack engineer, SRE, architect, platform/DevOps engineer or IT leader who enjoyed Part 1 – or you’re just curious how high-traffic sites keep their web layer fast, safe and flexible – this Part 2 is packed with real-world patterns, trade-offs and career insights you can take back to your own org. If you’re a frontend or full-stack engineer, SRE, architect, platform/DevOps engineer or IT leader who enjoyed Part 1 – or you’re just curious how high-traffic sites keep their web layer fast, safe and flexible – this Part 2 is packed with real-world patterns, trade-offs and career insights you can take back to your own org. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

How SEEK Builds Frontends: React, Design Systems & more (with Jahred Hope)

Tue, 18 Feb 2025 14:00:00 -0000

Frontend is “just HTML and CSS”, right? Not at SEEK. In this episode of SEEK Bytes – a podcast by engineers for engineers – we sit down with Jarrod Hope, Engineering Manager for Frontend Practices, to explore how SEEK builds UIs at scale with React, Braid, SKU, Vanilla Extract and Playroom, and why good frontends are genuinely hard, high-impact engineering problems. This episode's special guest: Jared Hope (SEEK Engineering Manager, Frontend Practices) In this episode you’ll learn: • How SEEK’s frontend platform works under the hood – from micro frontends and the SKU meta-framework to Metropolis, which lets teams share React components and roll out design-system updates across 80+ apps without chaos. • Why SEEK invests in open source tools like Braid, Playroom and Vanilla Extract – how “building in the open” raises quality, shapes the broader frontend community, and gives engineers type-safe CSS, shared UI language with designers, and zero-config prototyping. • Why SEEK doubled-down on React (and what’s next) – the original shift from Razor to server-rendered React, what it would take to move frameworks, and how tools like Vite, Suspense and better CSS module systems are shaping the future of the “experience platform”. Whether you’re a frontend engineer, full-stack dev, engineering manager, architect or curious IT generalist, this episode is a behind-the-scenes tour of how a large tech org thinks about UI, frameworks, tooling and open source – and how those decisions ripple through the wider web community. Whether you’re a frontend engineer, full-stack dev, engineering manager, architect or curious IT generalist, this episode is a behind-the-scenes tour of how a large tech org thinks about UI, frameworks, tooling and open source – and how those decisions ripple through the wider web community. 👍 Follow the SEEK Bytes podcast so you never miss a new episode

Thriving Through Change: Real- World Tech Transformations (with Sarah Duffy)

Tue, 11 Feb 2025 14:00:00 -0000

Org restructures. New tools. Platform migrations. That “we’re changing how everything works” email. If you work in IT, change is your default setting – but it doesn’t always feel that way. In this episode of SEEK Bytes, Elliott Millar, Will and special guest Sarah Duffy (Enterprise Change Lead at SEEK) unpack how to thrive in continuous change, not just survive it. This episode's special guest: Sarah Duffy (SEEK Enterprise Change Lead) In this episode, we explore: • What your brain is doing during change (and how to make it “brain-friendly”) – including the SCARF model (status, certainty, autonomy, relatedness, fairness), why change can trigger fight-or-flight, and how clear comms, certainty about the plan and fair processes dramatically reduce stress. • How SEEK runs large-scale change without “doing it by email” – from the Unification rollout across six countries to leader shark-tank sessions, change-champion networks and co-creation via focus groups, end-user testing and continuous listening to resistance as a source of insight. • Practical tools to personally thrive in change – including the IKEA effect and co-creation, the ACCESS framework (acknowledge, calm, challenge, exercise, social, sleep), sleep-hygiene tips, and simple techniques like box breathing and SCARF self-assessments you can use at your desk during stressful transitions. If you’re in software engineering, data, product, support, people leadership or any IT role facing restructures, tool changes or big programs, this episode gives you science-backed frameworks and everyday habits to handle change with more confidence – and help your teams do the same. If you’re in software engineering, data, product, support, people leadership or any IT role facing restructures, tool changes or big programs, this episode gives you science-backed frameworks and everyday habits to handle change with more confidence – and help your teams do the same. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Side Projects in Tech: Motivation, Money & Finishing What You Start

Tue, 04 Feb 2025 14:00:00 -0000

Got half-finished apps, tools and games sitting in your GitHub? You’re not alone. In this episode of SEEK Bytes, Seamus, Elliott and Will kick off Season 2 by diving deep into side projects in tech – why we start them, why they stall, and how to actually ship things alongside a full-time IT job. In this episode, we explore: • Where great side-project ideas really come from – using annoying real-world problems, interview prep and portfolio goals to spark projects that matter (and look great on GitHub). • How to fight decision-fatigue and stay motivated – why “projects about nothing” fizzle, how tiny, shippable increments beat grand architectures, and practical tactics like shrinking scope, embracing “good enough” and expecting motivation slumps from day one. • Balancing passion, learning and paid side work – real stories of late-night coding, paid gigs on game sites, internal tools like Conductor that became critical at SEEK, and why sometimes your day job’s learning and L&D time are all the “side project” you need. Whether you’re a software engineer, tester, data person, SRE, sysadmin or IT manager thinking about a side hustle, a portfolio piece, or just a fun game on the side, this episode will help you pick better projects, manage your energy and actually finish more than you start. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Trust, but verify - Never Trust Your Code: Bugs, CDNs & Leaky Abstractions

Tue, 16 Jul 2024 15:00:00 -0000

Your tests are green, coverage is high, dependencies are “secure”… so why does production still feel like a house of cards? In this episode of SEEK Bytes, Raph, Will and Elliott dig into trust in tech – from subtle JavaScript bugs and leaky abstractions to CDN attacks and noisy security reports – and why a healthy dose of skepticism is one of the most powerful tools an IT pro can have. In this episode, we explore: • How trust can be broken at every layer – from third-party CDNs like polyfill.js injecting malicious scripts, to chatbots pulling in compromised resources, to noisy vulnerability reports that burn out open source maintainers. • Why abstractions are powerful… and treacherous – what “leaky abstractions” really mean in practice, how unknown-unknowns derail estimates, and why learning just one layer deeper (query plans, caches, orchestration platforms) can save you from nasty surprises in production. • How to adopt a healthy “trust, but verify” mindset – treating tests and coverage as signals not guarantees, double-checking rollouts, reading docs and source instead of relying on hearsay, and staying just skeptical enough to catch the next Heartbleed-class bug before it bites you. Whether you’re in software engineering, QA, security, SRE, data, platform, or IT leadership, this episode will sharpen your instincts about what (and who) to trust in your stack – and how to balance healthy paranoia with getting real work shipped. Whether you’re in software engineering, QA, security, SRE, data, platform, or IT leadership, this episode will sharpen your instincts about what (and who) to trust in your stack – and how to balance healthy paranoia with getting real work shipped. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode Resources: • https://www.bleepingcomputer.com/news/security/dev-rejects-cve-severity-makes-his-github-repo-read-only/ • https://lab.wallarm.com/polyfill-io-supply-chain-attack-malicious-javascript-injection-puts-over-100k-websites-at-risk/ • https://carbon-steel.github.io/jekyll/update/2024/06/19/abstractions.html

REST API Best Practices: Design, Errors, Rate Limits & Monitoring

Tue, 02 Jul 2024 20:55:00 -0000

REST is everywhere in tech – but “we have a REST API” doesn’t mean it’s easy to use, safe or scalable. In this episode of SEEK Bytes, Will, Seamus and Elliott break down the real-world best practices that turn yet-another-endpoint into an API your consumers (and SREs) actually love – from URL design and validation to rate limiting, async jobs and monitoring. In this episode, we explore: • What REST really means in practice – why it’s an architectural style not just CRUD, the role of statelessness, resource-oriented design, and how REST compares to SOAP, GraphQL and gRPC in real SEEK systems. • How to design APIs that are predictable and easy to use – covering plural resource names, clean URIs, versioning strategies, status codes that actually mean something, filtering/sorting/pagination, strong yet flexible validation, and OpenAPI-driven docs and SDKs. • The “grown-up” side of APIs: performance, safety and observability – why good monitoring and logs are non-negotiable, how to think about SLAs and error budgets, using rate limiting to protect your business and your users, and avoiding both under- and over-logging. Whether you’re a software engineer, SRE, architect, platform/DevOps engineer or IT manager, this episode gives you a concrete checklist (and plenty of war stories) for building REST APIs that are easier to consume, safer to operate and much kinder to your users’ networks and your own infrastructure. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Inside SEEK’s AI Platform: Search, Speed & Systems Engineering (with Ren Shao)

Tue, 18 Jun 2024 15:00:00 -0000

AI gets all the hype – but behind every “smart” feature is a blisteringly fast, brutally efficient platform making it work in production. In this episode of SEEK Bytes, Seamus, Will and Elliott sit down with Ren Shao, a Staff Engineer in SEEK’s Artificial Intelligence Platform Services (AIPS) team, to unpack how SEEK’s AI-driven search really works under the hood – from models and rankings to GeoHash, big-O and CPU caches. This episode's special guest: Ren Shao (SEEK Staff Engineer) In this episode, we explore: • How SEEK’s AI search actually works under the hood – from turning “17-year-old jobs” into normalized queries, to ranking 200K+ jobs in real time, to using historical clicks and impressions to learn what candidates really mean. • Why this is more “systems engineering” than sci-fi AI – big-O thinking, GeoHash-powered radius search, clever use of CPU caches and HashMaps, and the “latency numbers every programmer should know” that turn textbook algorithms into production-grade platforms. • How to break into AI platform roles without a PhD – the difference between data engineers, data scientists and “small systems” engineers at AIPS; why curiosity about internals matters more than memorising neural nets; and how open-source code, sites like Codewars and tools like Hugging Face can be your on-ramp. If you’re in software engineering, data, SRE, platform, architecture or IT leadership and want to see what real-world AI platforms actually look like – not just the buzzwords – this episode is a masterclass in building fast, safe and scalable systems that power millions of job searches every day. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Time Zones Will Break Your Brain: Date/Time Nightmares in IT

Tue, 04 Jun 2024 15:00:00 -0000

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

Distributed Teams That Work! (with Laavanya Kathiresen and Jerome Chan)

Tue, 21 May 2024 15:00:00 -0000

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

Unifying SEEK’s Tech Stack (Part 2): Time, Trade-offs & CTO Truths (with James Ross)

Tue, 07 May 2024 15:00:00 -0000

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

How SEEK Unified APAC: A 430M-User Tech Transformation (with James Ross)

Tue, 23 Apr 2024 15:00:00 -0000

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

Lessons Learned the Hard Way: Tech Careers, Managers & Mentors

Tue, 09 Apr 2024 15:00:00 -0000

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

Stop Killing Your Focus: Slack, Meetings & Deep Work in Tech

Tue, 26 Mar 2024 14:00:00 -0000

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

From Junior to Senior: Busting Big Tech Career Myths

Tue, 12 Mar 2024 14:00:00 -0000

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

NPM Chaos, AI Type Safety & Imposter Syndrome in Tech

Tue, 13 Feb 2024 14:00:00 -0000

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

Fast, Safe JavaScript: Node vs Deno vs Bun for IT

Tue, 30 Jan 2024 14:00:00 -0000

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

Dev Tools That Developers Love: Building, Supporting and Sunsetting Internals

Tue, 16 Jan 2024 14:00:00 -0000

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

Tech Health, Not Tech Debt: Keeping Systems Fit at Scale (with Troy Mcilvena)

Tue, 02 Jan 2024 14:00:00 -0000

“Tech debt” sounds scary – but what if you reframed it as tech health and made it everyone’s job to keep systems fit, fast and supportable? In this episode of SEEK Bytes, Will, Nick and special guest Troy Mcilvena, Head of Architecture (Online) at SEEK, unpack how SEEK moved from hand-wavy tech debt complaints to a clear, business-aligned tech health model that works from startups through to large enterprises. This episode's special guest: Troy Mcilvena (SEEK Head of Architecture - Online) In this episode, we explore: • Why SEEK talks about tech health instead of tech debt – how binary, subjective “debt” language fails with executives, and how framing work in terms of security, performance, recovery, efficiency, availability and deployability (SPREAD) gets you real buy-in and a bigger slice of your OKRs. • How SEEK measures and governs tech health at scale – from monthly “wall walks” with CTO/CPO reviewing SPREAD alongside product metrics, to Tech Health’s five pillars (security, fitness for purpose, technical fit, speed & agility, supportability), to criticality and tolerance models that say “this must never go down, this can tolerate a day on paper forms.” • Practical advice to start your own tech health model – why you should begin with a painful business problem (not a shiny internet framework), anchor everything in revenue, trust and conversion, use SLO experiments (even injecting errors/latency) to find “good enough”, and design ownership, system boundaries and catalogues that make it clear who owns what and when to rewrite vs retire. If you’re a software engineer, architect, SRE, platform lead or IT manager wondering how to justify “non-feature” work, balance OKRs between “run the business” and “shift the business”, and stop surprise rewrites or outages, this episode is packed with language and tools you can take straight back to your teams. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Optus Outage, OpenAI Upgrades & Data Disasters: IT War Stories

Tue, 19 Dec 2023 14:00:00 -0000

A national telco goes dark, OpenAI drops GPT-4 Turbo, and hard drives start randomly deleting terabytes of data – this high-energy Mixed Byte episode of SEEK Bytes is a chaos tour through the realities of modern IT. Will, Seamus and Elliott Millar break down what happened, why it matters, and what every technologist should be thinking about next. In this episode, we explore: • Inside the Optus mega-outage – 10+ million customers offline, rail networks and even hospitals impacted, a federal investigation launched, and what it teaches us about incident management, DR and working on systems that underpin critical infrastructure. • What OpenAI’s Dev Day really means for IT – custom GPTs trained on your proprietary code and docs, models that can infer how microservices connect, help you find system owners and surface inefficiencies, plus GPT-4 Turbo’s huge 128K context window and lower pricing. • Backup horror stories & the true cost of losing data – from LAN-party hard drives literally burning out and wiping 10–15 years of music and photos, to external drives dying mid-copy and eye-watering $1,000+ data-recovery quotes that only enterprises (or lawyers) can justify. • Cloud vs physical storage for modern IT teams – why many of us now trust autosynced cloud photo libraries and object storage, when spinning disks and tape still make sense, and how data scale (from personal files to petabytes of 8K video) completely changes your backup strategy. If you work in software, cloud, data, networking, ops or security, this episode is packed with “that could be us” moments – plus practical takeaways for resilience, AI adoption and not losing the only copy of your life’s work. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Inside SEEK’s Grad Program: Launching IT Careers (with Scott Dann and Ben Swart)

Tue, 05 Dec 2023 14:00:00 -0000

Thinking about your first job in tech or a career switch into IT? SEEK’s software engineering grad program might be your launchpad. In this episode of SEEK Bytes, SEEK engineers sit down with Scott Dann (Graduate Program Manager) and Ben Swart (current grad) to unpack how the program works, who it’s for, and why it’s designed to grow people as much as technical skills. This episode's special guests: Scott Dann (SEEK Graduate Program Manager) and Ben Swart (SEEK grad) In this episode, we explore: • How SEEK’s 13-month grad program actually works – from the one-month Accelerator bootcamp to two six-month rotations grads choose themselves, PitchFest “Shark Tank” team pitches, and a “learn first, deliver naturally” philosophy that takes the pressure off breaking prod on day one. • Who can apply (and what SEEK really looks for) – why there’s no requirement for a CS degree, how grads have joined from biotech, civil engineering, OT and career-change backgrounds, and why SEEK optimises for passion, teamwork, curiosity, problem-solving and continuous learning over “10x coders.” • How the program lifts the whole engineering culture – creating mentors and future leaders, rotating grads through teams to spread best practices, building a 50+ person alumni community, boosting diversity, and even inspiring new grad streams in strategy, data, security and architecture. Whether you’re a student, bootcamp grad, career-switcher or IT leader thinking about talent pipelines, this episode lifts the lid on what a modern, people-first grad program can really do for tech careers – and for the teams around them. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

IDE Wars & Dark mode drama: The Tools IT Pros swear by

Tue, 21 Nov 2023 14:00:00 -0000

Which tools are winning the real IDE wars – and does your setup secretly say more about you than your job title? In this episode of SEEK Bytes, Elliot Miller, Seamus Kearney and William Lark unpack the ongoing battle between editors, IDEs and themes across software engineering, cloud, DevOps, data and more. From VS Code vs IntelliJ/WebStorm vs Notepad++ and Vim to light mode vs dark mode and AI copilots baked into your editor, they explore what actually makes IT work faster, safer and more fun – no matter where you sit in the stack. In this episode, we explore: How the original Vim vs Emacs editor wars started – and why those flame wars still shape today’s IDE choices across engineering, DevOps and sysadmin roles • Why VS Code has surged to the top of Stack Overflow’s surveys, and where heavyweight tools like Visual Studio, IntelliJ, Android Studio and Rider still shine for large codebases, game dev and enterprise apps • The surprisingly passionate light vs dark mode debate – including accessibility, colour-blindness, multi-window setups with Slack and browsers, and how your theme can genuinely impact comfort and focus • How AI tools like GitHub Copilot and natural-language “Lego programming” might change IDEs completely, from writing tests for you to a future where you barely see code at all Whether you’re a software engineer, SRE, cloud engineer, data practitioner or IT generalist, if you live in terminals, dashboards and editors all day, this one will have you rethinking your toolkit – and probably your theme as well. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

No “Right” Way In: Real Pathways into Software Development

Tue, 07 Nov 2023 14:00:00 -0000

Uni degree, masters, or self‑taught from YouTube and side projects – which path actually works? In this episode of SEEK Bytes, engineers Seamus, Will and Rahul share their very different journeys into software development, from traditional computer science and hardware‑heavy degrees to late‑start uni and learning on the job. They dig into what really made the difference: access to information, motivation, structure and the people around them. They explore why access to MIT‑level content online isn’t enough on its own, how competition and community can push you further, and why perseverance, feedback and good mentors often matter more than the specific pathway you choose. In this episode, we explore: • How different routes into tech – formal degrees, masters, bootcamps, online courses and self‑taught projects – shape your skills and confidence • The role of structure, competition, mentors and face‑to‑face learning in actually finishing what you start and becoming employable • Practical advice on ongoing learning: choosing resources, building real projects, and crafting a path that fits your life, goals and learning style If you’re a student, career‑switcher or early‑career developer wondering how to break into software – or keep levelling up once you’re in – this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Developer Experience Unlocked: Flow State, Fast Feedback & Happier Engineers

Tue, 24 Oct 2023 14:00:00 -0000

Ever feel like your dev day is harder than it needs to be? In this episode of SEEK Bytes, senior engineers Will, Seamus and Reyna unpack developer experience (DevEx) – what it really means, why it’s tied to burnout and retention, and how it shows up everywhere from tools and tests to tickets and team culture. They break DevEx down into three core dimensions – flow state, cognitive load and feedback loops – then explore how things like empty Jira cards, slow CI, unclear docs, pairing styles and communication norms can either support or destroy your ability to get into the zone and ship. In this episode, we explore: • What developer experience actually is, why it matters for productivity, quality and retention, and how it connects directly to developer burnout • The flow / cognitive load / feedback loop triangle – and how things like empty tickets, missing context and long builds quietly make your job much harder than it needs to be • Tools and practices that boost DevEx: pairing, Copilot and AI helpers, SKU/Skuba, Braid, Prettier/ESLint, TypeScript, strong architecture and naming that “screams” intent If you’re a software engineer, tech lead or platform engineer who cares about making everyday dev work smoother, faster and more enjoyable, this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

From Developer to Head of Engineering: Building Powerful People (with Lester Dong)

Tue, 10 Oct 2023 14:00:00 -0000

Wondering what it really takes to lead engineers – not just manage tickets? In this episode of SEEK Bytes, Bridget, Seamus and Elliot sit down with Lester Dong, Head of Selection at SEEK, to talk about the leap from developer to engineering leader and what it means to “build powerful people”. Lester shares how he moved from hands‑on software development into management, how he now looks after 56 engineers across three teams, and why great engineering leadership is about context, scaling yourself, and solving human problems – not just technical ones. This episode's special guest: Lester Dong (SEEK Head of Engineering - Selection) In this episode, we explore: • Engineer vs developer (and why it matters for your career) – moving from “just writing code” to joining the dots between systems, people and business outcomes, building self-awareness, and learning to zoom in to bugs then “helicopter out” to see the bigger picture. • How to grow from ammo to “barrel” and beyond – Lester’s take on ammunition vs barrels, solving bigger problems to move up, collaborating instead of competing for the one tech-lead slot, and using rotations and context to build a career that outgrows any single team. • Patterns, microservices & high-performing teams (without the hype) – why design patterns and microservices get overused when people don’t understand the problem, how Seek thinks about monoliths vs microservices, and the practical signals of healthy teams: build pipelines, flaky tests, and change-failure rates under 5%. If you’re a software engineer, tech lead or aspiring manager who wants to grow beyond code and lead high‑impact teams, this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Coding Interviews, .zip Domains & Dev Burnout: Mixed Bytes Mayhem

Tue, 26 Sep 2023 15:00:00 -0000

Scammy .zip domains, spicy takes on coding interviews, and whether English should “own” programming languages – all in one episode. In this Mixed Bytes instalment of SEEK Bytes, Will, Seamus and Reyna jump between security, hiring and career sustainability in modern software engineering. They unpack why new .zip and .mov TLDs are a phishing dream, share honest perspectives on take‑home tests and live coding, and dig into what really drives developer burnout – plus how swapping teams, resetting challenge levels and finding meaning in your work can help. They wrap by asking whether it’s okay that most code is written in English, and what non‑English programming languages and comments mean for inclusion and learning. In this episode, we explore: • How new .zip and .mov top‑level domains can turn innocent file names into malicious links – and why that’s a huge UX and security problem for everyday users • The pros and cons of coding exercises in interviews: live vs take‑home, algorithm grills vs domain modelling, and why there’s no perfect, bias‑free way to hire • Real talk on developer burnout – from never‑ending projects and constant upskilling to lack of recognition – and practical ways to reset through team moves, people leadership and better support • Whether it’s healthy that most code and docs are in English, and what non‑English languages, comments and symbolic languages mean for accessibility in our industry If you’re a software engineer or student who cares about security, fair interviews and staying in love with coding long‑term, this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Testing: What It’s Really Good For (Beyond Just Catching Bugs)

Tue, 12 Sep 2023 15:00:00 -0000

Write heaps of tests but still not sure you’re testing the right things? In this episode of SEEK Bytes, staff engineer Rahul Ballal joins the crew to dig into what testing is actually for, how it’s evolved from C++ and waterfall days to modern CI/CD, and why your users should never suffer because of your bugs. From testing pyramids, diamonds and honeycombs to TDD, BDD, black‑box, visual regression and property‑based testing, they unpack how to pick the right tests for your context, focus on the core business logic, and keep your feedback loops fast — whether you’re shipping web apps, data platforms or safety‑critical systems. In this episode, we explore: • How testing has changed from armies of manual QA to automation, feature flags, synthetic checks and “testing in production” • When to lean on unit, integration, end‑to‑end and black‑box tests – and how to aim them at the most important behaviour in your system • How TDD and BDD really work in practice, and why fast feedback plus confidence to change code are the real superpowers of a great test suite If you’re a software engineer, tester or tech lead trying to balance speed, safety and sanity in your testing strategy, this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

GraphQL in the Real World: How SEEK Powers Modern Apps (with Mark Cheeseman)

Tue, 29 Aug 2023 15:00:00 -0000

Seeing GraphQL everywhere at SEEK and wondering what it actually buys you? In this episode of SEEK Bytes, host Seamus Kearney is joined by Nik Skoufis, Reyna Tan and special guest Mark Cheesman to unpack how SEEK uses GraphQL across candidate and hirer systems – from the early “shared free‑for‑all” graph to today’s curated, high‑scale platform. They dig into what GraphQL really is (a query language and graph executor, not “just an API”), how resolvers and data sources work under the hood, and why SEEK leans on GraphQL to power experience APIs for web and mobile instead of hand‑rolling bespoke REST layers. This episode's special guest: Mark Cheeseman (SEEK Staff Engineer) In this episode, we explore: • What GraphQL actually is (beyond “an API”) – a query language and execution engine that turns your request into a graph and traverses it, not just “REST with curly braces” – and why it doesn’t even need HTTP under the hood. • Why SEEK moved from REST experience APIs to GraphQL – unifying messy mobile and web backends, replacing one-off “backend-for-frontend” services with a flexible query layer so clients can build their own experience APIs on every request. • Resolvers, data sources & performance at scale – how resolvers map to REST APIs, S3, caches and in-memory data, why SEEK prefers field-level resolvers and data-source caching, and how graph theory and query-complexity limits protect against “select * from everything” type queries. • Security, rate limiting & degraded behaviour – preventing scraping and abusive queries, using query-level rules on top of IP-based rate limiting, and designing for graceful degradation when upstream services are slow or down instead of treating the site as simply “up or down”. • Custodianship, observability & culture – why a shared graph needs an owning team, how SEEK uses OpenTelemetry, Datadog and custom metrics to see who’s calling what, find hotspots and retire unused fields, and how pairing and “graph custodians” help other teams onboard safely. If you’re a frontend, backend or full‑stack engineer trying to decide when GraphQL is worth it – or just want to understand SEEK’s graph stack better – this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Monoliths vs Microservices: Are We Overcomplicating Everything?

Tue, 15 Aug 2023 15:30:00 -0000

Heard “monoliths bad, microservices good” a few too many times? In this episode of SEEK Bytes, engineers Elliott Millar, Will Lark and Seamus Kearney pull apart the hype and get real about monoliths, microservices and monorepos – when each makes sense, and how messy the definitions get once you’re in real systems. From tiny startup apps and internal admin tools to large, distributed platforms with dozens of squads, they walk through scalability, deployment, team ownership, dependency nightmares and why a well‑built monolith can still be a great choice – even in 2025. In this episode, we explore: • What a monolith really is (beyond “big ball of mud”) – single codebases, single deploys, scale‑up limits and why they’re so powerful for early‑stage products and small teams • How microservices and distributed systems change the game on scalability, reliability and ownership – along with new headaches in orchestration, testing, dependencies and people‑coordination • Where monorepos fit in, why “good vs bad” isn’t the right lens, and how organisation, boundaries and team design matter more than chasing the latest architecture trend If you’re a backend or full‑stack engineer, architect or tech lead wrestling with “Should we split this up?”, this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Go Fetch, Datadog: Finding Bugs Before Your Users Do

Tue, 15 Aug 2023 15:20:00 -0000

Ever been on‑call with angry 500s in production and zero helpful logs? In this episode of SEEK Bytes, engineers Reyna Tan, Seamus Kearney, Will Lark and Elliott Millar dive into how SEEK uses Datadog as their go‑to observability platform – from metrics and traces to dashboards and on‑call. They unpack how Datadog helps them follow the full journey of a request across services, spot Dynamo and API issues, and use synthetic tests to run real login/apply flows in production – catching outages before customers do. Along the way they share tips on debugging with browser tools and the debugger keyword, and why learning tools like Datadog is a career‑level superpower, especially across big internal platforms and multiple squads. In this episode, we explore: • How Datadog ties together metrics, traces and APM so you can see end‑to‑end request lifecycles, pinpoint slow or failing dependencies, and support systems you didn’t build yourself • Using synthetic tests and monitors to continuously exercise real user flows in production, alerting PagerDuty when upstream auth, GraphQL or downstream services break • Why observability and debugging skills (Datadog dashboards, browser DevTools, the debugger keyword) are underrated force‑multipliers for grads and experienced engineers alike If you’re a software engineer, SRE or tech lead who wants fewer mystery outages and faster incident response, this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

ChatGPT vs Your Dev Job: Threat, Tool, or Superpower?

Tue, 15 Aug 2023 15:10:00 -0000

Using ChatGPT to write code, tests and essays – game over for engineers or just the next power tool? In this episode of SEEK Bytes, engineers Nick Skoufis, Bridget Barnes, Elliott Millar and Reyna Tan dive into what ChatGPT really is, where it shines, where it fails hard, and how it might change the day‑to‑day reality of software work. From asking it to refactor test suites, generate React and Webpack configs, or even build a text‑adventure Zork clone, through to security, cheating in coding tests, and mass tech layoffs, they unpack the hype, the risks and the genuinely useful ways to bring large language models into your toolbox – without handing them the steering wheel. In this episode, we explore: • How ChatGPT actually works under the hood (tokens, probabilities, “confidently wrong” answers) – and why you still need humans in the loop • Real‑world uses for developers: refactors, boilerplate, documentation, internal Q&A and dreaming about private, company‑only instances over your own codebase • What AI means for jobs, interviews and academia – from automation and coding tests to who actually gets replaced (and why that probably isn’t great engineers) If you’re a software engineer, student or tech lead trying to figure out how to use ChatGPT without letting it use you, this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode

Welcome to SEEK Bytes, a podcast FOR Software Engineers BY Software Engineers

Tue, 15 Aug 2023 15:00:00 -0000

Love the freedom of working from home but worried about what it’s doing to your growth and team culture? In this first episode of SEEK Bytes, engineers Elliott Millar, Bridget Barnes and Nik Skoufis get real about remote, hybrid and office life at SEEK – from pre‑pandemic experiments to fully remote roles and everything in between. They talk about the upsides (no commute, more time with pets and kids, flexible schedules) and the trade‑offs: missing out on incidental learning, cross‑team connections and those random hallway chats that turn into career‑shaping insights – and how they’ve learned to deliberately recreate that online. In this episode, we explore: • How SEEK engineers were already experimenting with WFH before the pandemic – and what changed when offices suddenly shut • Practical ways to keep incidental learning, mentoring and cross‑team serendipity alive in a remote‑first world • Why communication, internal tools and informal time are the glue for effective remote teams – and how SEEK structures in‑office days and “forced fun” so they actually work If you’re a software engineer, early‑career dev or tech lead trying to figure out what great remote/hybrid work really looks like, this episode is for you. 🔔 Follow the SEEK Bytes podcast so you never miss a new episode