Static Website

Static Website

How to build a static website, KISS principle

Here's a guide to building a static website, embracing the KISS (Keep It Simple, Stupid) principle:

1. Choose the Right Tools:

  • Static Site Generator (SSG): Hugo or Astro are great options, each with its strengths (covered in my previous response). Consider your preferences for templating, interactivity, and JavaScript involvement.

  • Text Editor: A simple text editor like VS Code, Atom, or Sublime Text is sufficient.

  • Basic HTML and CSS Knowledge: Familiarity with these foundational web technologies is essential.

2. Design and Structure:

  • Keep It Simple: Opt for a clean, uncluttered design that focuses on content and usability.

  • Plan Navigation: Create a clear and intuitive menu structure for easy navigation.

  • Organize Content: Use folders to group related pages and assets for better maintainability.

3. Write Content:

  • Markdown: Use Markdown for effortless content creation and formatting.

  • Focus on Value: Provide meaningful information relevant to your audience.

  • Structure Clearly: Use headings, lists, and images to break up text and enhance readability.

4. Build the Website:

  • Follow SSG Instructions: Use the chosen SSG's commands to generate the static HTML files.

  • Preview Locally: Test the website thoroughly on your computer before deploying.

5. Deploy:

  • Choose a Host: Select a static hosting provider like Netlify, Vercel, or GitHub Pages.

  • Upload Files: Transfer the generated HTML files to your hosting platform.

KISS Tips:

  • Start Small: Begin with a basic structure and add features gradually as needed.

  • Prioritize Content: Focus on delivering valuable information rather than complex features.

  • Avoid Bloat: Keep JavaScript and external libraries to a minimum for optimal performance.

  • Test Thoroughly: Ensure cross-browser compatibility and responsiveness on different devices.

  • Iterate and Improve: Continuously review and refine your website based on user feedback and analytics.

Remember: Simplicity often leads to better user experiences and easier maintenance. By following these steps and embracing the KISS principle, you can create a static website that effectively delivers your message without unnecessary complexity.

Static website generators (SSGs):

Static website generators are tools that pre-render HTML files from templates and content, eliminating the need for a server to generate dynamic content on the fly. This leads to faster loading times, improved security, and lower costs. Let's delve into Astro and Hugo, comparing their advantages and disadvantages:



  • Component-based development: Write reusable components using your preferred JavaScript framework (React, Vue, etc.) or web components, promoting modularity and code reuse.

  • Partial hydration: Only interactive elements hydrate with JavaScript, while static content remains pre-rendered, resulting in a balance between fast initial load and interactivity.

  • JavaScript flexibility: Use any existing JavaScript libraries or frameworks without worrying about bloat, as only necessary parts are included in the final build.

  • Markdown support: Write content in familiar Markdown format alongside JS components for easy content creation.

  • Hot reloading: See changes instantly during development without rebuilds, improving development speed.


  • JavaScript reliance: Requires JavaScript knowledge and might involve configuring frameworks, adding a learning curve.

  • Younger ecosystem: Compared to Hugo, Astro has a smaller community and fewer ready-made themes and plugins.

  • Beta stage: While stable, Astro is still under development, so breaking changes and potential bugs might occur.



  • Blazing fast: Hugo is renowned for its speed, generating websites extremely quickly due to its Go-based build process.

  • Simple templating language: Learn the straightforward Golang-inspired templating language with ease, even for non-programmers.

  • Extensive theme and plugin ecosystem: Choose from an abundance of ready-made themes and plugins to jumpstart your website and add various functionalities.

  • Mature and stable: Hugo is a well-established tool with a large community and active development, minimizing bug encounters.

  • Static site benefits: Hugo delivers all the core advantages of SSGs like security and ease of hosting.


  • Limited interactivity: Hugo focuses on static content, making complex dynamic interactions challenging without JavaScript knowledge.

  • Framework lock-in: While themes and plugins offer functionality, integrating complex frameworks can be cumbersome.

  • Templating flexibility: Hugo's templating language, while simple, has less flexibility compared to component-based development in Astro.

Choosing the right one:

  • Astro: Choose Astro if you want flexibility with JavaScript frameworks, prioritize component-based development, and are comfortable with a slightly steeper learning curve and a younger ecosystem.

  • Hugo: Choose Hugo if you value blistering speed, prefer a simpler templating language and an extensive theme/plugin library, and need a stable and mature solution for content-heavy websites.

Ultimately, the best SSG depends on your project's specific needs and comfort level with different technical aspects. Both Astro and Hugo are excellent tools for building performant and secure static websites, so consider your priorities and preferences when making your choice.


Svelte, on its own, doesn't provide every feature needed for a complete static and dynamic website out of the box. However, it offers a strong foundation for building such websites when combined with complementary tools and frameworks.

Here's a breakdown of key considerations:

Features Svelte excels at:

  • Component architecture: Ideal for structuring and organizing UI elements.

  • Reactivity: Efficiently manages state changes and updates the UI accordingly.

  • Performance: Generates small, optimized code for fast loading and execution.

  • Developer experience: Simplifies common tasks with a clean syntax and intuitive API.

Features requiring additional tools:

  • Static site generation (SSG): While Svelte can generate static HTML, dedicated SSGs like Astro or integration with build tools like Vite provide a more streamlined experience for building static sites.

  • Server-side rendering (SSR): Using Svelte with frameworks like SvelteKit or Sapper enables server-side rendering for improved SEO and initial load performance.

  • Data fetching: Svelte doesn't include built-in data fetching mechanisms, but it integrates well with libraries like SWR for efficient data management.

  • Routing: For complex routing scenarios, SvelteKit or Sapper provide robust routing solutions.

Overall, Svelte offers a powerful core for building web experiences, but it's often best complemented by additional tools to address specific needs like SSG, SSR, data fetching, and complex routing. This approach allows developers to leverage Svelte's strengths while ensuring a complete web development toolkit.

If you wish to help please create content for my static website, visit the project and start reading about software engineering. If you like this kind of content you can help by continuing the project. Submit tickets on GitHub when you have suggestions for new content, or signal errors.

Disclaim: This article is 90% generated with AI. Comment below if you use one of these tools to create your website. Let me know what you think is better.

Did you find this article valuable?

Support Elucian Moise by becoming a sponsor. Any amount is appreciated!