Where I actually learned to code — my OJT at nCase PH

June 2024 – January 2025 — I started in June, took a break through October, picked back up in November, and wrapped up in January 2025.

If you asked me where I actually learned to code, the honest answer isn't school — it's my OJT at Passafund, now nCase PH. That's where I started from zero and had to learn everything from scratch, because school was nowhere near the real coding experience.

Starting from zero

I walked in thinking I knew how to program. I didn't — not really. School taught me concepts; nCase taught me how software actually gets built. The gap between the two was humbling, and closing it was the whole point of being there.

My stack became Laravel on the backend and Vue on the frontend. Everything was new: routing, migrations, components, state, APIs that other people actually depended on. I learned it the only way that sticks — by building real things and breaking them first.

More than just code

What surprised me most was how little of the training was only about code. We learned leadership, and how a team is actually supposed to work together. We ran Agile development and studied clean code every morning — it wasn't a nice-to-have, it was part of the daily rhythm.

That habit changed how I think. Writing code that works is easy to fake once; writing code your teammates can read, trust, and build on is a different discipline entirely.

Standup in the morning, scrum in the afternoon

Our days were bookended by two check-ins. A daily standup in the morning to line up what we were about to do, and a daily scrum in the afternoon to look back on it. We'd cover the usual three: what went well, what we were going to do next, and what our blockers were.

What I appreciated most is that it was never only about the technical side. We could talk about our day too — how we were actually doing. It made the team feel like people working together, not just tickets moving across a board.

Sessions with Teacher Arnlee

Every Wednesday and Friday we had our sessions with Teacher Arnlee. We'd discuss what we'd taken from clean code principles, and he'd hand us LeetCode problems to work through.

Those sessions were where the ideas got tested — it's one thing to read about clean code, another to defend a decision or untangle a problem you've never seen before in front of people who'll ask why.

Monday UMP — Upscaling and Mentorship

Every Monday we had UMP (Upscaling and Mentorship). This was the part that had nothing to do with syntax and everything to do with growing up as a professional. We learned about leadership, how to think, how to handle criticism, and all the things that don't show up in a code review but decide whether you last in this field.

The sessions ran on a rotation — one week would be led by Teacher Gil, the next by Teacher Gen, and so on — though more often than not it was Teacher Gil, our CEO, leading the discussion. Having the CEO himself regularly sit down to talk about mindset and growth said a lot about what the company cared about.

Learning to take criticism without taking it personally is a skill I still lean on every single day.

The people who made it

A big part of what made nCase click was the people guiding us.

• Teacher Parbs was our team leader — our direct go-to whenever we hit a wall or had a question. Having someone you can actually turn to changes how fast you learn.
• Teacher Gen was the company's UI/UX engineer. Working near that craft taught me how much thought goes into how a product feels, not just whether it works.
• Miss Gail, the company psychologist and admin, would check in on us — asking about our experience and how things had been lately. That kind of care is rare, and it mattered.
• Teacher Gil, the CEO, was hands-on with us — he led most of our UMP sessions himself, and every now and then he'd also invite us out to eat.

That mix — technical mentors, someone looking after how we were doing, and a CEO who led our mentorship sessions and shared a meal — is why the place felt less like an internship and more like a team that genuinely wanted us to grow.

The project: PassaQuiz

While in OJT we built a real project — a dynamic quiz app called PassaQuiz — and the road to it was a lesson in itself. We started by proposing some initial ideas for the quiz app, and they got declined. So we went back, thought about it harder, and out of that the dynamic quiz app took shape.

It's where I learned the full development process end to end: planning, designing, development. PassaQuiz had two sides:

• a customer-facing website where people take the quizzes
• an admin panel to create and manage quizzes and participants

Getting it accepted was not a straight line. We presented it — and it got turned down. We refined it and presented again, and it was turned down a second time; it still wasn't usable to their standard. We kept working at it, and on the next round it was finally accepted. That acceptance is where our OJT journey ended.

Owning something from a rejected pitch to an accepted product taught me more than any single tutorial ever did. I saw why planning matters, why design decisions ripple into the code, how much work lives after a feature "works" — and that hearing "no, not yet" is just part of building something people will actually use.

What I took with me

nCase PH is where the foundation was poured — the technical stack, but also the mindset: clean code as a default, Agile as a way of working, and the humility to keep learning. I came in thinking I could code. I left actually knowing how.

Everything I've built since started here.