Technology choices have a significant impact on the success of software development projects as well as on the sustainability, usability, and cost of the software produced by the project [1]. At the start of a project the main platform technologies are often defined, and during the project additional choices are made for individual use cases and features. In this post I go through some considerations that should be taken into account when making different technology choices.
Platforms
The most important factor when choosing a platform is the software's requirements in relation to the platform's features. Often a simple virtual server is sufficient and fast scalability or deep integration into cloud ecosystems and services is not needed. In such cases running and maintaining the application is usually cheaper and simpler. Additionally, switching platforms is typically fairly straightforward if required. Cloud services may be needed when automatic scaling, near 100% availability, or some other technical requirement demands them. Companies may also already use a particular cloud provider in other projects, in which case it can make sense to build new projects on the same platform.
From a security and privacy perspective, the physical location of servers and the provider's home country are important. For example, US companies may be compelled to hand over data stored on their servers to the government under the CLOUD Act [2]. It can therefore be useful to prefer European providers such as Hetzner or domestic providers such as UpCloud or Seclan when data protection is a primary requirement.
From a sustainability standpoint it is worth recognizing a platform's energy consumption and the methods used to produce that energy. The Green Web Foundation maintains a registry of platforms' environmental impact [3]. It is also advisable to favor platforms that provide comprehensive tools for tracking environmental impact.
AI
An increasing number of software systems use AI models to implement particular functionality. Although language models are fashionable, they are not always the right solution. Before using language models, assess whether their capabilities suit the intended task and decide accordingly. When using language models, choose models and providers so that you use the smallest model capable of performing the task with the required confidence. This saves costs and energy consumption and speeds up model usage. Such models are also easier to run in your own infrastructure or on a user device, reducing the impact of provider‑specific pricing and availability changes on the software's behavior and costs.
In some applications it is necessary to run larger models or there may be reasons not to run models in your own infrastructure. In that case it is useful to use tools like OpenRouter or similar, which allow swapping models or using multiple models for different purposes without changing the interface. This also helps avoid vendor lock‑in with a specific model provider.
From a privacy and data‑protection perspective the same considerations apply to model providers as to platforms — the provider's location matters. Unfortunately, most AI model providers are based in either the United States or China. Mistral is perhaps the best‑known European provider of AI models.
Programming languages
New programming languages are released continuously and existing languages gain new features and improvements. At the same time, technologies often remain in use for a long time, and adoption of new languages is usually fairly slow. Languages also serve many different purposes and one language is rarely the best choice for every problem.
When choosing a programming language, consider the platform's support for that language. For example, cloud platforms vary in their language support. Likewise, hardware can influence which languages are appropriate. In embedded systems, low‑level languages such as C, C++, Rust, and Zig are typically the best options.
Technical language features should also be taken into account. A strong type system and error handling help maintain code quality and slow the accumulation of technical debt during a project. Such languages force you to handle many potential error conditions before code can be run. Finding errors during development instead of in the hands of end users is often desirable. Performance‑oriented languages may also directly reduce runtime costs and energy consumption [4].
The development team's expertise is another important factor. Although many developers can learn a new language quickly, it is good to check whether an already familiar language would solve the problem. That reduces the time developers spend getting comfortable with the language.
Programming languages have varying library ecosystems and a major factor in choosing a language is whether required functionality is already available. This can significantly speed up development, but relying on third‑party libraries exposes software to supply‑chain attacks where malicious packages are injected into centralized package registries such as NPM. When using external libraries, check whether the library is actively maintained and consider whether implementing the feature in‑house might be easier. It is also important to include automated monitoring of dependencies in the CI/CD pipeline.
A relatively new factor is the influence of AI tools on technology selection. Choices may be influenced by how well a model can generate or answer questions about a particular language. The risk is choosing a technically inferior solution because you do not trust your own or the team's ability to adopt more suitable technologies without extensive external assistance. Current AI models are also competent enough that they can generate code in nearly any widely used language well enough for many tasks.
Frameworks
Especially in web applications it is common to build software on top of a framework that implements many common features. Frameworks often steer developers to implement things in a specific way (often called opinionated frameworks). Frameworks exist for frontend, backend, or both. Examples of TypeScript frameworks include Express.js, Next.js, and SvelteKit.
Choosing a framework can significantly affect application performance even when the programming language remains the same, so performance considerations are an important part of framework selection.
When selecting a framework consider its suitability for your use case, update support, and features. Strongly opinionated frameworks are usually pleasant to use when your use case is well supported. However, you may find yourself in a situation where the framework does not support a desired capability and you must implement difficult workarounds.
Runtimes
Some languages allow choosing the runtime environment. For example, the JavaScript/TypeScript ecosystem has three commonly used runtimes: Node, Deno, and Bun. Each has its pros and cons. Node is the most widely used and best supported, but it is often slower than Deno and Bun. Deno focuses strongly on security by requiring explicit permission for many actions, such as file access. Running third‑party library scripts is also blocked by default. Bun is the newest and by many metrics the fastest.
The choice of runtime depends on the software's requirements, the company's development practices and tooling requirements, and the platform's support for the runtime. Also note that some libraries may support only a specific runtime.
Databases
SQL‑based databases are dominant and most feature‑complete. Common SQL databases are PostgreSQL and MySQL, which are good choices for the primary database in most projects. SQLite has also gained popularity recently due to its simplicity and is commonly used as a local client‑side database. Other databases should be considered if their features better suit the application or a particular functionality. For example, the Discord messaging platform uses ScyllaDB to store and retrieve very large volumes of messages quickly [5].
With the rise of AI applications, vector databases have also become common components. Although both PostgreSQL and SQLite offer vector extensions as plugins, it may be more useful to deploy a dedicated vector database because those extensions are not comparable in features and performance to purpose‑built vector databases [6]. This is especially important if AI retrieval is a critical part of the application's functionality.
AI development tools
The use of AI‑based development tools has also grown rapidly, although their real impact on productivity is still debatable [7] and many productivity estimates are based on user surveys that may not reliably measure actual productivity [8]. These tools can generate a lot of content quickly, which seems efficient, but much of that content can be superfluous or partly incorrect on closer inspection. This low‑value content appears both in generated code and other outputs such as documentation, making code reviews more burdensome and time‑consuming for project leads. Unpredictability and variable quality are major weaknesses of these tools, combined with hype that can obscure their actual capabilities. Additionally, these tools risk weakening developers' understanding of code and systems and reduce ownership — code may be perceived as produced by AI and not treated with the same responsibility as hand‑written code.
There are ways to improve the usefulness of these tools. First, the AI models used by the tools are important for output quality. Anthropic's Claude Opus and Claude Sonnet models are still among the best for code generation. OpenAI's Codex models are also capable, and Google recently released the Gemini 3 model which by many metrics appears to be close to the models mentioned above [9]. For locally run models, Qwen3‑coder‑30b is a good balance of quality and hardware requirements when quantized to about 18GB of memory. Second, the development team must be aware of the risks above and ensure developers take full responsibility for AI outputs; responsibility should not be outsourced to AI.
AI tools are most useful in prototyping and rapid idea validation. They also work well for well‑defined and isolated problems. Reliability and quality suffer as the codebase grows, although this can be mitigated. AI works better when the project structure and documentation are already consistent. Additionally, having a specification file (for example an "agents.md") that documents code structure and practices for AI use is helpful. This makes it easier for models to build features that align with the existing structure. The size of the model's context window is also a significant factor in output quality as the codebase grows, since otherwise the model cannot process the entire codebase at once and will "forget" details. For AI tools it is recommended to use vendor‑agnostic tooling that permits easy switching between models. This avoids vendor lock‑in, since AI tool and model providers may rapidly raise prices or throttle models. Opencode is one example of a tool meeting these requirements. Local model execution is possible with tools like Ollama and LM Studio.
Code quality tools
Most projects use at least two tools to improve code quality: a formatter and a linter. Formatters unify code appearance according to rules so that code written by different developers looks consistent and readable. Linters search for common errors and potential issues in code and suggest fixes.
Development tools are important both for developers and for AI models. Many AI tools, such as the previously mentioned Opencode, allow models to run other development tools and thereby gather information about bugs in the program and modify code accordingly. Tools should be as fast and resource‑efficient as possible so iteration stays quick and development is feasible on lower‑power machines.
New development tools are released occasionally and it is useful to check at the start of a project whether newer tools are available rather than blindly reusing tools from previous projects. For example, in the TypeScript ecosystem Biome has largely replaced Prettier and ESLint in my usage; it combines features of both and is much faster and more resource‑efficient. Similarly, in Python Ruff and uv have replaced Black, flake8, isort, and pip for me for the same reasons. Better development tools speed up automated quality checks in CI/CD pipelines in addition to helping developers.
Testing tools
Testing plays an important role in software quality assurance. Many languages' ecosystems now include some testing capability, and it is usually a good idea to adopt that early. It can also be beneficial to adopt third‑party testing tools because they may be more advanced and provide useful features like test coverage tracking and test report visualization.
References
[1] T. Rinne, "Adapting Sustainable Software Development Methods Into Agile Processes", UTUPub, 2024.
[2] Eurojust, "The CLOUD Act", https://www.eurojust.europa.eu/publication/cloud-act, 2022
[3] Green Web Foundation, "The Green Web Directory", https://app.greenweb.org/directory/, [Accessed Dec. 8, 2025]
[4] T. Salonen, "Green Coding and Energy Efficiency in REST APIs: Empirical Evaluation", UTUPub, 2025.
[5] B. Ingram, "How Discord Stores Trillions of Messages", https://discord.com/blog/how-discord-stores-trillions-of-messages, 2023, [Accessed Dec. 8, 2025]
[6] A. Jacobs, "The Case Against pgvector", http://alex-jacobs.com/posts/the-case-against-pgvector/, 2025, [Accessed Dec. 8, 2025]
[7] N. Dunlap, "AI coding assistants increase developer output, but not company productivity", https://www.faros.ai/blog/ai-software-engineering, 2025, [Accessed Dec. 8, 2025]
[8] J. Becker, N. Rush, E. Barnes, D. Rein, "Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity", https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study, 2025, [Accessed Dec. 8, 2025]
[9] Google, https://storage.googleapis.com/deepmind-media/Model-Cards/Gemini-3-Pro-Model-Card.pdf, 2025
