Blog / / 9 min read

From idea to production

What I’d tell anyone starting out: how software really gets built, from the first conversation to the day people use it.

By Thor Remiendo, software engineer in Baguio City

  • Talk
  • Software lifecycle
  • Agile
  • Career

Most people picture our job as someone typing code. That’s the tip of the iceberg. Below the waterline is understanding the problem, design, architecture, testing, security, deployment, maintenance, teamwork, and a lot of talking to humans. I gave a talk on all of it, and this is the written version.

The gap that matters

I opened the talk with three questions and asked for a show of hands. Who has written code? Almost everyone. Who has built a complete app? Fewer. Who has had strangers use something they built? A few hands, and that’s normal.

The whole talk is about that last jump, from “I built it” to “people use it”. That’s where most of the real learning happens.

This is a beginner-friendly walkthrough of the software development lifecycle (SDLC). It has seven phases: Discover, Design, Architect, Build, Test, Ship and Operate, and it loops.

Discover(01)DiscoverDesign(02)DesignArchitect(03)ArchitectBuild(04)BuildTest(05)TestShip(06)ShipOperate(07)Operatewhat you learn in Operate goes straight back into DiscoverDiscover(01)DiscoverDesign(02)DesignArchitect(03)ArchitectBuild(04)BuildTest(05)TestShip(06)ShipOperate(07)Operate…and it loops: Operate feeds Discover.
School teaches this as a waterfall. In real life you go around the loop many times.

Sit with the people first

A request usually says “build us a system”. The real problem is somewhere else. On one project, getting a building permit took 143 days. After we mapped where the days actually went and fixed that bottleneck, it took 5. The software helped because we watched the work before we wrote any code.

Once you’ve watched, you’ll have a pile of complaints. Designers turn each one into a question that starts with “How might we…”. How assumes there’s a fix, might means there can be many answers, and we means we build it with the users. “How might we build an app?” is not a question. It’s a solution pretending to be one.

Design is psychology

Good design works with how brains actually behave. A few instincts that have names:

  • Chunking: a long number is unreadable until you group it. That’s why phone and card numbers are split up.
  • Hick’s law: the more choices you show, the longer people take to decide. Ten equal links make people freeze; three clear ones let them move.
  • Jakob’s law: people spend most of their time in other apps, so a familiar pattern beats a clever new one.
  • Fitts’s law: bigger, closer targets get tapped. A tiny checkbox is annoying; a large button isn’t.

My favourite exercise is the five-second test. Show a page for five seconds, hide it, and ask what it was for. If people can’t say, the page has too many jobs. None of this is talent. It’s learnable, the same way the code is. And find your design mistakes while they’re cheap: a sketch costs minutes to change and code costs weeks.

Boring is a feature

Three developers, one client, six months, about 500 users. Do you need microservices? No. The big-tech architectures on YouTube solve big-tech problems. One well-organised app with clear modules and a managed database is the right call, and you can split it later if it starts to hurt. Pick the simplest design that survives the next two years. Scalable doesn’t mean microservices on day one; it means a design that can grow when real usage demands it.

Write down why you chose it: context, decision, consequences, on one page. Decisions change, and a written reason makes changing them safe.

And design for the network your users actually have. Field staff often work where there’s no signal, so the app saves to the phone first and syncs when signal returns. The one rule: never lose what the user typed.

Write for the next person

Code is read far more often than it’s written. Three habits carry most of the weight:

  • A readable history. “final na talaga” is not a commit message. Conventional Commits let you find the bug that broke production in seconds.
  • Clear beats clever. Names that say what the code does, no magic numbers, and return the condition directly. If code needs a comment to explain it, rename it first.
  • Small pull requests. A 3,000-line PR gets a “looks good to me”. A small one gets a real review.

Let tools argue: a formatter and a linter settle the tabs-versus-spaces fight automatically. Keys and URLs live in environment files, never in the code.

Prove it works, and keep it safe

Testing comes in three levels: many fast unit tests, some integration tests, and a few end-to-end tests that drive a real browser. Tests have to do what the real user does, or they give false confidence. Ours once passed while real users couldn’t log in, because the test faked the network call and never hit the browser’s security check. A green test on a broken product. Since then, login and API tests go through the real network.

On security, here’s my favourite demo. You’re looking at your own record, and your ID is in the URL. Change one digit and you’re looking at someone else’s. That’s an insecure direct object reference, one of the most common real-world bugs. The fix is one line on the server: is this record yours? Hiding a button doesn’t make anything secure. And never commit passwords or API keys, because Git keeps the history.

Shipping is boring, on purpose

Putting a new version live should be routine and predictable, not a stressful all-hands moment. That’s CI/CD: every change goes through the same pipeline, a failing test stops it, and a green one reaches staging, then production.

And go-live is day one, not the end. A system built in months runs for years, so most of your time on it will be maintenance: support tickets, change requests when a policy changes, security patches, and backups. A backup you’ve never restored is just a hope. Everything that comes back from Operate becomes the input for the next version.

A day in the life

Everything above happens inside a rhythm. Agile is a mindset: build in small pieces, show real users early, change course when you learn something. Scrum is the most common way to do it, and a sprint is a fixed box of time, usually two weeks, that ends with working software. The week goes like this:

  1. Planning: the team picks what it can actually finish.
  2. Daily standup: fifteen minutes. Yesterday, today, blockers. It surfaces problems; it doesn’t solve them.
  3. Refinement: getting next sprint’s work ready.
  4. Review and retro: demo the work, then talk honestly about how you worked. Every action gets an owner. Blame the process, not the person.

On the board, “done” doesn’t mean it works on my machine. It means merged, deployed and verified.

Beyond the code

A professional is measured by how they work with people, not only by their code. If a teammate is waiting on me, I clear that first. Juniors are scared to say “I don’t know”; seniors say it every day and then find out.

On AI: I use it every day and it’s a real speed-up, but it’s confidently wrong sometimes, and its mistakes look reasonable. Use it to learn faster, not to skip learning. If you can’t explain the code, you don’t own it. Read every line you ship. A developer with AI will beat one without it, but be the one who also understands the code.

Start this week

None of this costs money, and none of it depends on whether you end up in frontend, backend, mobile or QA.

  1. Build two or three portfolio projects you can show and explain.
  2. Put your work on GitHub. It’s the first place people look.
  3. Learn fundamentals over frameworks. Frameworks change every few years.
  4. Read the docs and the error message before you ask. Most answers are in them.
  5. Use AI tools every day, and understand every line you submit.
  6. Join a hackathon or community. One weekend teaches more than a month of tutorials.
  7. Practice explaining your work. Talking to humans is half the job.

Want the slides or have a question? Email me at thorremiendo@gmail.com.

← All notes