What Is Development Technology?

Key points

  • Development technology is a catch-all term for the technical choices and design thinking involved in actually building a system — "how do we deliver it," "how do we build the screens," "how do we exchange data," and "how do we organize the code."
  • There isn't one single correct answer — you choose based on the scale and purpose of what you're building.
  • Representative examples include "Jamstack," "SPA," "REST API design," and "architecture patterns (MVC, etc.)."
🖥️ Choices around the screen Jamstack (delivery method) SPA (screen transition method)
🗄️ Choices around data and structure REST API design (data exchange) Architecture patterns (code organization)

Teacher Pochi uses apps and sites like this every day, too

📱 Using apps 🌐 Browsing sites 🛍️ Shopping
JamstackThis site loads incredibly fast — how is it actually being delivered? SPAThis app switches screens with zero loading flicker — how does that work? REST API DesignHow do a phone app and a server actually exchange data behind the scenes? Architecture PatternsHow does the code behind a big app stay organized instead of turning into a mess?

What "development technology" actually refers to

When you hear "development technology," you might picture the name of a specific programming language or framework. But this category deals with something one step earlier than that.

When building a system, before you get into implementation, you need to make structural decisions: "what mechanism will we use to deliver it," "how will we build the screens," "how will we design the data exchange," and "how will we organize the code." Development technology is the umbrella term for these choices and ways of thinking.

Why technology choice matters

Even with the same goal of "building a website," the technology you choose has a big impact on how easy development is, how fast the site loads, and how easy it is to add features later. Changing an entire architecture after the fact tends to involve a lot of rework.

Teacher Pochi's hintThis is similar to choosing a construction method when building a house. Whether you go with wood framing or steel framing affects how easy it is to build, how durable it is, and how easy it is to renovate later. Switching construction methods after the work has started is a major undertaking, which is why getting the initial choice right matters so much.

Choosing a delivery method: Jamstack

There's more than one way of thinking about how to deliver a web page. Instead of the traditional approach — where the server assembles the HTML fresh on every request — there's an alternative: build the HTML ahead of time, then deliver it as-is.

Generate HTML
at build time
Deliver as-is
Fast, secure
rendering

This is the idea behind "Jamstack." We cover it in more detail in its own topic.

Choosing how screens are built: SPA

Instead of the traditional approach of swapping out the entire page for each screen, there's another way of building things: load a single HTML file up front, then let JavaScript rewrite the screen's contents from there on.

Load just one
HTML file up front
JS rewrites it
The screen changes
with no page transition

This is the "SPA (Single Page Application)" approach. We cover it in more detail in its own topic.

Designing data exchange: REST API

The screen (frontend) and the side that manages data (backend) usually communicate through an API. There's a way of thinking about how to design this API, and the most representative style is called "REST."

URLrepresents "what the data is" (e.g., /users)
HTTP methodrepresents "what to do" (GET, POST, etc.)

Separating "the target (resource)" from "the operation" is the basic idea behind REST. We cover it in more detail in its own topic.

How code gets organized: architecture patterns

The bigger an app gets, the harder the code becomes to read if screen appearance, data processing, and overall control are all crammed into one place. A "pattern" that organizes code by splitting it into distinct roles is called an "architecture pattern," and the most representative example is "MVC (Model, View, Controller)."

Model
Data
Controller
Control
View
Screen display

We cover it in more detail in its own topic.

These technologies are used together

Jamstack, SPA, REST API design, and architecture patterns aren't really independent, either-or choices — in real systems, they're often combined. For example, it's not unusual to see a page built with Jamstack calling a REST API, with part of that page then rewritten by JavaScript in SPA fashion.

Teacher Pochi's hintThis is similar to planning a meal. "What's the main dish," "how do we cook the entrée," and "how do we plate it" are each separate decisions, but together they add up to a single meal (the system).

Summary

Development technology is a catch-all term for the technical choices and design thinking behind how a system is delivered, how its screens are built, how data is exchanged, and how its code is organized. Jamstack, SPA, REST API design, and architecture patterns are among the most representative ideas in this space.

You can dig deeper into each of these in the dedicated topics below.

Related topics:

🏠 Back to top