Software Engineer Intern

Peakhill Capital; Toronto; On-site; CAD 70,000 - 110,000; Full time

Job summary

Peakhill Capital is seeking a motivated and analytical individual to join our software team. You’ll translate needs into practical solutions, support new initiatives, and test and improve what we build.

This is a hands‑on role for someone who enjoys problem solving, learning how systems work, and turning ideas into action. You’ll collaborate with business and technical teams, write clear Jira stories and documentation, and help move initiatives forward.

Qualifications

• Strong communication in writing and speaking.
• Curiosity to understand how software works and why it behaves as it does.
• Ability to manage multiple threads, follow up, and close loops without reminders.
• Attention to detail; investigating beyond the first answer.
• Healthy skepticism to identify edge cases and potential issues.
• Comfort with ambiguity and adapting priorities without losing momentum.

Responsibilities

• Understand the ask by collaborating with cross‑functional teams to uncover true needs.
• Break down large requirements into clear, achievable work items.
• Keep the big picture in mind and align tasks with team priorities.
• Learn the system deeply: how it works, how changes interact, and potential downstream impacts.
• Capture clear notes; coordinate meetings; keep conversations moving toward decisions.
• Test existing functionality and new features from multiple angles; document issues clearly.
• Write Jira stories, bug reports, and acceptance criteria; document steps to reproduce.

Skills

Strong communication

Curiosity

Organization and initiative

Attention to detail

Healthy skepticism

Comfort with ambiguity

Tools

Jira

Git

Job description

We are seeking a motivated and analytical individual to join our software team. You’ll work closely with both business and technical teams to translate needs into practical solutions, support new initiatives, and test and improve what we build.

This is a hands-on role for someone who enjoys problem-solving, learning how systems work, and turning ideas into action.

What You’ll Do

Understand the ask

• Work with teams across the organization to uncover what they actually need — not just what they initially ask for.
• Break large or ambiguous requirements into clear, achievable pieces of work.
• Keep the bigger picture in mind and understand how individual requests fit into the team’s overall priorities.

Learn the system

• Develop a deep working knowledge of our application: what it does, how its pieces connect, and where its edges are.
• Evaluate how new requirements interact with existing functionality.
• Identify conflicts, overlaps, dependencies, and potential downstream impacts before they become expensive problems.

Keep things moving

• Capture clear, useful notes that people can rely on weeks later.
• Coordinate meetings, make sure the right people are involved, and keep conversations moving toward decisions.
• Follow up independently and close the loop on your own work. You shouldn’t need to be reminded to chase something down.

Break things

• Test existing functionality and new features from every angle.
• Try unexpected inputs, unusual workflows, and the things users probably weren’t supposed to click.
• Perform thorough manual testing with a sharp eye for detail — both the obvious visual inconsistency and the silent data issue matter.
• Be comfortable being the person who finds the problem. That’s the point.

Write it down

• Create clear Jira stories, bug reports, feature specifications, acceptance criteria, and meeting notes.
• Write documentation that allows someone who wasn’t in the room to understand the problem and take action.
• Clearly communicate reproducible steps, expected vs. actual behaviour, and what “done” actually means.

What We’re Looking For

These qualities matter more to us than any particular technology:

• Strong communication: You can communicate clearly in writing and in conversation.
• Curiosity: You genuinely want to understand how software systems work and are willing to dig until you do.
• Organization and initiative: You manage your own threads, follow up, and close loops without being chased.
• Attention to detail: “It works” is not the end of the investigation. It’s the beginning of the next question.
• Healthy skepticism: You naturally look for edge cases, inconsistencies, and things that could go wrong.
• Comfort with ambiguity: Priorities can shift, requirements can evolve, and you’re able to adapt without losing momentum.

You are not expected to know everything below.

We’ve intentionally grouped our stack into three tiers. Tier 1 is what we expect you to be comfortable with on day one. Tier 2 is where familiarity gives you an advantage and where you’ll grow on the job. Tier 3 is bonus territory.

Because much of this role involves understanding, evaluating, and testing software rather than building every feature end-to-end, being able to read code and reason about how it works counts. You don’t need production experience in every technology listed.

You should be comfortable with these fundamentals before you start:

• HTML & CSS: Layout, the box model, responsive behaviour, and understanding why something breaks at 375px.
• React: Components, props, state, and hooks — enough to read a component and reason about what it will render.
• SQL: Basic queries, tables, joins, and relationships.
• Git: Branching, commits, pull requests, and resolving a merge conflict without panicking.
• Jira or similar: Experience is great; genuine willingness to learn it properly in your first week is required.

Tier 2 — Strongly Preferred

Familiarity is valuable; depth is a real advantage. Gaps are absolutely something you can close on the job.

• TypeScript — our front end is primarily React + TypeScript.
• Tailwind CSS — our styling layer.
• Next.js — our React framework.
• PostgreSQL — our primary database, including schema design and more complex queries.
• C# / .NET Core — our back-end services.
• Entity Framework — ORM and data-access patterns.
• Prisma — ORM on the TypeScript side.
• Database migrations — understanding what they are and why careless migrations can be dangerous.
• Wireframing & workflow mapping — Figma, Excalidraw, or even a whiteboard; you can sketch a workflow before anyone writes code.
• UI/UX sensibility — you notice when something is technically correct but frustrating to use.

Nice to have, never a barrier. We’ll teach you what you need to know.

• AWS — EC2, RDS, SQS, CloudWatch, ECR, and the wider ecosystem.
• CI/CD — understanding how code moves from a branch to production.
• AI / LLM integrations — prompt design, API integration, and evaluating model output.
• Cloud infrastructure and deployment concepts more broadly.

What You’ll Get Out of It

This is an opportunity to develop a much broader understanding of software than you’d get from simply being handed tickets.

You’ll gain:

• A real, end-to-end view of how software is specified, built, tested, and shipped.
• Direct exposure to stakeholders across the business — not just the engineering team.
• Practical experience in requirements analysis, QA, technical writing, and software delivery.
• A strong foundation for future roles in software engineering, product, business analysis, QA, or technical operations.
• Hands-on exposure to a modern full-stack environment: React/TypeScript and Next.js on the front end, .NET Core and PostgreSQL on the back end, AWS underneath it all, and AI/LLM integration work alongside it.
• Meaningful ownership of your work, with support when you need it.

If you’re the kind of person who wants to understand why something works, figure out how it fits into the bigger picture, and isn’t afraid to break things in the process, we’d love to hear from you.