Header image

Automate Your Git Workflow with Git Hooks for Efficiency

24/12/2024

1.04k

Bao Dang D. Q.

Have you ever wondered how you can make your Git workflow smarter and more efficient? What if repetitive tasks like validating commit messages, enforcing branch naming conventions, or preventing sensitive data leaks could happen automatically? Enter Git Hooks—a powerful feature in Git that enables automation at every step of your development process.

If you’ve worked with webhooks, the concept of Git Hooks might already feel familiar. Like API events trigger webhooks, Git Hooks are scripts triggered by Git actions such as committing, pushing, or merging. These hooks allow developers to automate tasks, enforce standards, and improve the overall quality of their Git workflows.

By integrating Git Hooks into your project, you can gain numerous benefits, including clearer commit histories, fewer human errors, and smoother team collaboration. Developers can also define custom rules tailored to their Git flow, ensuring consistency and boosting productivity.

In this SupremeTech blog, I, Đang Đo Quang Bao, will introduce you to Git Hooks, explain how they work, and guide you through implementing them to transform your Git workflow. Let’s dive in!

What Are Git Hooks?

Git Hooks are customizable scripts that automatically execute when specific events occur in a Git repository. These events might include committing code, pushing changes, or merging branches. By leveraging Git Hooks, you can tailor Git’s behavior to your project’s requirements, automate repetitive tasks, and reduce the likelihood of human errors.

Imagine validating commit messages, running tests before a push, or preventing large file uploads—all without manual intervention. Git Hooks makes this possible, enabling developers to integrate useful automation directly into their workflows.

Type of Git Hooks

Git Hooks come in two main categories, each serving distinct purposes:

Client-Side Hooks

These hooks run on the user’s local machine and are triggered by actions like committing or pushing changes. They are perfect for automating tasks like linting, testing, or enforcing commit message standards.

  • Examples:
    • pre-commit: Runs before a commit is finalized.
    • pre-push: Executes before pushing changes to a remote repository.
    • post-merge: Triggers after merging branches.

Server-Side Hooks

These hooks operate on the server hosting the repository and are used to enforce project-wide policies. They are ideal for ensuring consistent workflows across teams by validating changes before they’re accepted into the central repository.

  • Examples:
  • pre-receive: Runs before changes are accepted by the remote repository.
  • update: Executes when a branch or tag is updated on the server.

My Journey to Git Hooks

When I was working on personal projects, Git management was fairly straightforward. There were no complex workflows, and mistakes were easy to spot and fix. However, everything changed when I joined SupremeTech and started collaborating on larger projects. Adhering to established Git flows across a team introduced new challenges. Minor missteps—like inconsistent commit messages, improper branch naming, accidental force pushes, or forgetting to run unit tests—quickly led to inefficiencies and avoidable errors.

That’s when I discovered the power of Git Hooks. By combining client-side Git Hooks with tools like Husky, ESLint, Jest, and commitlint, I could automate and streamline our Git processes. Some of the tasks I automated include:

  • Enforcing consistent commit message formats.
  • Validating branch naming conventions.
  • Automating testing and linting.
  • Preventing accidental force pushes and large file uploads.
  • Monitoring and blocking sensitive data in commits.

This level of automation was a game-changer. It improved productivity, reduced human errors, and allowed developers to focus on their core tasks while Git Hooks quietly enforced the rules in the background. It transformed Git from a version control tool into a seamless system for maintaining best practices.

Getting Started with Git Hooks

Setting up Git Hooks manually can be dull, especially in team environments where consistency is critical. Tools like Husky simplify the process, allowing you to manage Git Hooks and integrate them into your workflows easily. By leveraging Husky, you can unlock the full potential of Git Hooks with minimal setup effort.

I’ll use Bun as the JavaScript runtime and package manager in this example. If you’re using npm or yarn, replace Bun-specific commands with their equivalents.

Setup Steps

1. Initialize Git: Start by initializing a Git repository if one doesn’t already exist

git init

2. Install Husky: Use Bun to add Husky as a development dependency

bun add -D husky

3. Enable Husky Hooks: Initialize Husky to set up Git Hooks for your project

bunx husky init

4. Verify the Setup: At this point, a folder named .husky will be created, which already includes a sample of pre-commit hook. With this, the setup for Git Hooks is complete. Now, let’s customize it to optimize some simple processes.

verify the setup of husky git hooks

Examples of Git Hook Automation

Git Hooks empowers you to automate tedious yet essential tasks and enforce team-wide best practices. Below are four practical examples of how you can leverage Git Hooks to improve your workflow:

Commit Message Validation

Ensuring consistent and clear commit messages improves collaboration and makes Git history easier to understand. For example, enforce the following format:

pbi-203 – refactor – [description…]
[task-name] – [scope] – [changes]

Setup:

  1. Install Commitlint:
bun add -D husky @commitlint/{config-conventional,cli}
  1. Configure rules in commitlint.config.cjs:
module.exports = {
    rules: {
        'task-name-format': [2, 'always', /^pbi-\d+ -/],
        'scope-type-format': [2, 'always', /-\s(refactor|fix|feat|docs|test|chore|style)\s-\s[[^\]]+\]$/]
    },
    plugins: [
        {
            rules: {
                'task-name-format': ({ raw }) => {
                    const regex = /^pbi-\d+ -/;
                    return [regex.test(raw),
                        `❌ Commit message must start with "pbi-<number> -". Example: "pbi-1234 - refactor - [optimize function]"`
                    ];
                },
                'scope-type-format': ({ raw}) => {
                    const regex = /-\s(refactor|fix|feat|docs|test|chore|style)\s-\s[[^\]]+\]$/;
                    return [regex.test(raw),
                        `❌ Commit message must include a valid scope and description. Example: "pbi-1234 - refactor - [optimize function]".
                        \nValid scopes: refactor, fix, feat, docs, test, chore, style`
                    ];
                }
            }
        }
    ]
}
  1. Add Commitlint to the commit-msg hook:
echo "bunx commitlint --edit \$1" >> .husky/commit-msg
  1. With this, we have completed the commit message validation setup. Now, let’s test it to see how it works.
husky template git hooks

Now, developers will be forced to follow this committing rule, which increases the readability of the Git History.

Automate Branch Naming Conventions

Enforce branch names like feature/pbi-199/add-validation.

  1. First, we will create a script in the project directory named scripts/check-branch-name.sh.
#!/bin/bash

# Define allowed branch naming pattern
branch_pattern="^(feature|bugfix|hotfix|release)/pbi-[0-9]+/[a-zA-Z0-9._-]+$"

# Get the current branch name
current_branch=$(git symbolic-ref --short HEAD)

# Check if the branch name matches the pattern
if [[ ! "$current_branch" =~ $branch_pattern ]]; then
  echo "❌ Branch name '$current_branch' is invalid!"
  echo "✅ Branch names must follow this pattern:"
  echo "   - feature/pbi-<number>/<description>"
  echo "   - bugfix/pbi-<number>/<description>"
  echo "   - hotfix/pbi-<number>/<description>"
  echo "   - release/pbi-<number>/<description>"
  exit 1
fi

echo "✅ Branch name '$current_branch' is valid."
  1. Add the above script execution command into the pre-push hook.
echo "bash ./scripts/check-branch-name.sh" >> .husky/pre-push
  1. Grant execute permissions to the check-branch-name.sh file.
chmod +x ./scripts/check-branch-name.sh
  1. Let’s test the result by pushing our code to the server.

Invalid case:

git checkout main
git push

Output:

❌ Branch name 'main' is invalid!
✅ Branch names must follow this pattern:
  - feature/pbi-<number>/<description>
  - bugfix/pbi-<number>/<description>
  - hotfix/pbi-<number>/<description>
  - release/pbi-<number>/<description>
husky - pre-push script failed (code 1)

Valid case:

git checkout -b feature/pbi-100/add-new-feature
git push

Output:

✅ Branch name 'feature/pbi-100/add-new-feature' is valid.

Prevent Accidental Force Pushes

Force pushes can overwrite shared branch history, causing significant problems in collaborative projects. We will implement validation for the prior pre-push hook to prevent accidental force pushes to critical branches like main or develop.

  1. Create a script named scripts/prevent-force-push.sh.
#!/bin/bash

# Define the protected branches
protected_branches=("main" "develop")

# Get the current branch name
current_branch=$(git symbolic-ref --short HEAD)

# Check if the current branch is in the list of protected branches
if [[ " ${protected_branches[@]} " =~ " ${current_branch} " ]]; then
# Check if the push is a force push
for arg in "$@"; do
  if [[ "$arg" == "--force" || "$arg" == "-f" ]]; then
    echo "❌ Force pushing to the protected branch '${current_branch}' is not allowed!"
    exit 1
  fi
done
fi

echo "✅ Push to '${current_branch}' is valid."
  1. Add the above script execution command into the pre-push hook.
echo "bash ./scripts/prevent-force-push.sh" >> .husky/pre-push
  1. Grant execute permissions to the check-branch-name.sh file.
chmod +x ./scripts/prevent-force-push.sh
  1. Result:

Invalid case:

git checkout main
git push -f

Output:

❌ Force pushing to the protected branch 'main' is not allowed!
husky - pre-push script failed (code 1)

Valid case:

git checkout main
git push

Output:

✅ Push is valid.

Monitor for Secrets in Commits

Developers sometimes unexpectedly include sensitive data in commits. We will set up a pre-commit hook to scan files for sensitive patterns before committing to prevent accidental commits containing sensitive information (such as API keys, passwords, or other secrets).

  1. Create a script named scripts/monitor-secrets-with-values.sh.
#!/bin/bash

# Define sensitive value patterns
patterns=(
# Base64-encoded strings
"([A-Za-z0-9+/]{40,})={0,2}"
# PEM-style private keys
"-----BEGIN RSA PRIVATE KEY-----"
"-----BEGIN OPENSSH PRIVATE KEY-----"
"-----BEGIN PRIVATE KEY-----"
# AWS Access Key ID
"AKIA[0-9A-Z]{16}"
# AWS Secret Key
"[a-zA-Z0-9/+=]{40}"
# Email addresses (optional)
"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
# Others (e.g., passwords, tokens)
)

# Scan staged files for sensitive patterns
echo "🔍 Scanning staged files for sensitive values..."

# Get the list of staged files
staged_files=$(git diff --cached --name-only)

# Initialize a flag to track if any sensitive data is found
found_sensitive_data=false

# Loop through each file and pattern
for file in $staged_files; do
# Skip binary files
if [[ $(file --mime-type -b "$file") == "application/octet-stream" ]]; then
  continue
fi

# Scan each pattern using grep -E (extended regex)
for pattern in "${patterns[@]}"; do
  if grep -E -- "$pattern" "$file"; then
    echo "❌ Sensitive value detected in file '$file': Pattern '$pattern'"
    found_sensitive_data=true
    break
  fi
done
done

# If sensitive data is found, prevent the commit
if $found_sensitive_data; then
echo "❌ Commit aborted. Please remove sensitive values before committing."
exit 1
fi

echo "✅ No sensitive values detected. Proceeding with committing."
  1. Add the above script execution command into the pre-commit hook.
echo "bash ./scripts/monitor-secrets-with-values.sh" >> .husky/pre-commit
  1. Grant execute permissions to the monitor-secrets-with-values.sh file.
chmod +x ./scripts/monitor-secrets-with-values.sh
  1. Result:

Invalid case:

git add private
git commit -m “pbi-002 - chore - add unexpected private file”

Result:

🔍 Scanning staged files for sensitive values...
-----BEGIN OPENSSH PRIVATE KEY-----
❌ Sensitive value detected in file 'private': Pattern '-----BEGIN OPENSSH PRIVATE KEY-----'
❌ Commit aborted. Please remove sensitive values before committing.
husky - pre-commit script failed (code 1)

Valid case:

git reset private
git commit -m “pbi-002 - chore - remove unexpected private file”

Result:

🔍 Scanning staged files for sensitive values...
✅ No sensitive values detected. Proceeding with commit.
[main c575028] pbi-002 - chore - remove unexpected private file
4 files changed, 5 insertions(+)
create mode 100644 .env.example
create mode 100644 .husky/commit-msg
create mode 100644 .husky/pre-commit
create mode 100644 .husky/pre-push

Conclusion

“Humans make mistakes” in software development; even minor errors can disrupt workflows or create inefficiencies. That’s where Git Hooks come in. By automating essential checks and enforcing best practices, Git Hooks reduces the chances of errors slipping through and ensures a smoother, more consistent workflow.

Tools like Husky make it easier to set up Git Hooks, allowing developers to focus on writing code instead of worrying about process compliance. Whether it’s validating commit messages, enforcing branch naming conventions, or preventing sensitive data from being committed, Git Hooks acts as a safety net that ensures quality at every step.

If you want to optimize your Git workflow, now is the time to start integrating Git Hooks. With the proper setup, you can make your development process reliable but also effortless and efficient. Let automation handle the rules so your team can focus on building great software.

Related Blog

Hackathon AI SupremeTech 2025

Our culture

+0

    A to Z about SupremeTech’s AI Hackathon 2025: Why We Do It and What to Expect

    This September 6–7, SupremeTech will host its first AI-Driven Development Hackathon, a landmark event designed to inspire teams to embrace artificial intelligence as a core part of how we work, innovate, and grow. The Hackathon is not just a competition. It is a statement of SupremeTech’s belief that learning and innovation are the backbone of both personal and organizational growth. Through this event, our engineers and product teams will have the opportunity to experiment, challenge themselves, and use AI to reimagine the way they work. By fostering creativity and adaptability, the Hackathon aims to enhance work efficiency today while leading the way for AI-assisted development as a core strength of our future. Why Hackathon Matters Now There are several ways companies may choose to approach and apply AI in their working process: training, workshop,… For SupremeTech we want to inspire our developers with a fun blend of innovative and competitive experiences. Hackathon is exactly the format we’re looking for. They compress ideation, experimentation, and execution into an intensive timeframe, creating an environment where bold ideas can quickly turn into actionable solutions. Furthermore, the high pressure of time would foster teamwork, collaboration and bonding to the next level. At SupremeTech, the AI Hackathon 2025 will serve as: A safe space to test AI ideas from concept to execution.A platform to help employees step out of their comfort zones and practice product-building skills.An accelerator of cross-functional teamwork, where developers, designers, and product leaders work together with AI as a co-pilot.A signal to clients and partners that SupremeTech is forward-looking, innovation-driven, and committed to AI adoption. SupremeTech AI Hackathon 2025 Overview Message & Objective:To raise awareness of the importance of continuous learning, growth, and self-breakthrough, enabling each individual to move forward together in collective progress. Format:The main theme of this Hackathon is “AI-Driven Development” focusing on how teams can utilize AI tools to build solutions and solve real-world problems.  Teams will have 22 hours to complete their challenge, followed by a 30-minute demo and pitching session to the judges. Results will be announced after the competition. Evaluation Criteria:Projects will be assessed across four dimensions: Business Value: Market fit, feasibility, economic efficiency, and contribution to SupremeTech’s brand.Engineering Quality: Coding standards, scalability, maintainability, security, and UI/UX design.Technical Execution: Completion of core features, testing outcomes, innovative use of AI tools, and potential for future expansion.Presentation & Pitching: Clarity of communication, demo quality, time management, team passion, and user experience. Main Business Domains Covered: The Hackathon challenges will center on the Retail sector, with a strong emphasis on Omnichannel and Luxury Retail Businesses. Within this domain, teams will explore AI-driven solutions in three key areas: Customer ExperienceMobile OrderingCustomer Data What Leaders Think About This AI Hackathon To provide insight into the vision behind the Hackathon, we spoke with its three leaders of SupremeTech, who directly run this initiative: Mr. Bình (CEO), Mr. Vĩ (Vice President), and Mr. Đào (CTO). Mr. Bình, CEO of SupremeTech “2025 is a turning point for us, a second-time startup for SupremeTech. The industry is moving very fast with AI, and I want our people to be at the front line of this change, not just following behind.” For Mr. Bình, the Hackathon is about more than prototypes. It is about building a culture where innovation and continuous learning are second nature. He hopes the event will give SupremeTech members the awareness that AI is not some distant future, but a tool they can apply today to enhance their work. To clients and partners, the Hackathon demonstrates that SupremeTech is serious about innovation and ready to bring AI-driven value into real projects. Mr. Vĩ, Vice President of SupremeTech From his perspective, the Hackathon plays a strategic role in long-term talent development. “Hopefully, through this AI hackathon, we will contribute to spreading the AI-assist mindset to a large number of company members, thereby popularizing AI in all projects at SupremeTech. In order to improve efficiency and quality, optimize costs to bring benefits to customers and the company.” He expects to see teams not only moving fast but also integrating AI across the entire development process. Beyond internal growth, the Hackathon sends a message to clients: SupremeTech is building a strategic roadmap for AI-assisted development that will optimize costs, shorten delivery time, and raise product quality. Mr. Đào, CTO of SupremeTech When judging, Mr. Đào will look for a balance between creativity and practical application. Both, he believes, are equally important. “The role of developers will not change much, but their skills will. Engineers will need to level up, becoming more capable as they learn to work alongside AI.” For him, the Hackathon represents a chance for teams to explore while ensuring their ideas can translate into real-world impact. >>> Read more related articles: How a Hackathon Changed My Life – A Personal Story from the CEO of SupremeTechHow Could You Join a Hackathon Without Knowing This? Our Developers Are Preparing for D-Day As the countdown to September 6 approaches, excitement is building across SupremeTech. Teams are forming, ideas are being exchanged, and strategies are taking shape. For our developers, this Hackathon is more than just a challenge, it is a chance to step outside their comfort zones, test their skills under pressure. Stay Tuned for Our Upcoming Updates The SupremeTech AI Hackathon 2025 is the beginning of a larger journey. It is about preparing people to work smarter with AI, strengthening a culture of innovation, and ultimately shaping the future of AI-assisted development in SupremeTech and beyond. By creating this space for learning and experimentation, SupremeTech is reaffirming its commitment to being both a reliable partner today and a forward-looking innovator tomorrow. 📩 Read more articles about us here: https://www.supremetech.vn/blog/

    05/09/2025

    26

    Our culture

    +0

      A to Z about SupremeTech’s AI Hackathon 2025: Why We Do It and What to Expect

      05/09/2025

      26

      When Technology Meets a Pioneering Spirit

      Our culture

      +0

        When Technology Meets a Pioneering Spirit

        SupremeTech’s Hackathon 2025 is not just a coding competition, it’s a place where bold ideas are tested, limits are broken, and new connections are formed. Every team carries its own story – about why they joined, their role in the group, or what they expect to gain after this intense yet inspiring journey. Among them, we had the chance to chat with Quang Dũng, a Technical Leader at SupremeTech, who is participating in a Hackathon for the very first time – while also taking on the role of team leader. Usually busy with deadlines and lines of code, this Hackathon is his opportunity to step away from routine work and challenge himself in a completely different way. We listened to his thoughts on challenges, pioneering spirit, and what he hopes to take away from this event. Let’s join SupremeTech and Quang Dũng in this conversation about the Hackathon! Q&A with Quang Dũng 1. Is this your first time joining a Hackathon?Yes, this is my first Hackathon. Everything feels new: the intensity, the pressure, and how teamwork changes under strict time limits. I wanted to experience this firsthand and compare it with the usual way of running projects. 2. What made you decide to sign up for the event?I wanted to challenge myself – to see how far I can go applying AI in real-world work. This is an opportunity for me and my team to pioneer ways of leveraging AI Copilot in a small group project of 3–5 people, while learning new workflows and testing practical applications. And of course, the prizes are also very attractive – hard to resist! Who knows, maybe I can go home and tell my wife that just two days of Hackathon brought back 50 million VND! (laughs). 3. What is your role in the team? If given the choice, what field would you like your project to be applied to?I’m the team leader – responsible for planning, setting the initial direction, and building a sample demo so everyone has a clear vision. In other words, I set the rhythm so the whole team can work smoothly together. If I had the chance to choose a project topic, I’d want it applied to practical areas like booking/reservation systems or internal management tools such as resource and project management. These fields are highly relevant to business needs and can create immediate value. 4. If you had to describe SupremeTech’s AI Hackathon in three words, what would they be? Challenge – Pioneer – Connection. Challenge: because everyone here must push beyond their own limits.Pioneer: because we are applying the latest AI technologies to real-world problems.Connection: connecting people, ideas, and the future of technology. 5. What do you expect to gain from this Hackathon? In my daily work, I’m often involved in project estimation. I expect this event will help me learn how to integrate AI Copilot into product development workflows. That could make estimations more accurate, save time, and improve overall efficiency at the company. In other words, what I look forward to most is not just the prize, but the knowledge and experience that can truly be applied to work. >> Read related articles: How a Hackathon Changed My Life – A Personal Story from the CEO of SupremeTech Closing SupremeTech’s Hackathon is more than a tech playground, it’s an opportunity for each individual to test themselves, learn, and break past their own limits. Stay tuned for the next tech journeys at SupremeTech, where even the smallest ideas can spark big changes!

        22/08/2025

        168

        Our culture

        +0

          When Technology Meets a Pioneering Spirit

          22/08/2025

          168

          tips when joining AI Hackathon

          Knowledge

          +0

            How Could You Join a Hackathon Without Knowing This?

            In the ever-evolving world of programming, the emergence of intelligent support tools is changing the way we write code. Copilot, often described as “AI-powered Pair Programming”, promises to revolutionize the workflow of software developers. In this article, I’ll focus on GitHub Copilot, the AI tool I personally use every day when coding. What is GitHub Copilot? GitHub Copilot is an AI assistant integrated into IDEs (VS Code, IntelliJ IDEA/PyCharm, Neovim) developed by GitHub and OpenAI. It provides context-aware code suggestions as you type, and includes Copilot Chat for Q&A directly inside the IDE. Key Advantages of GitHub Copilot Faster coding: Reduce time spent on repetitive tasks with context-aware suggestions (functions, code blocks, basic tests).Learn new technologies quickly: Get API/syntax examples directly in your IDE; ask further via Copilot Chat.Automate boring work: Scaffold endpoints, write boilerplate, create sample tests, suggest snippets, and ensure consistent formatting.Seamless IDE integration: Works in VS Code, JetBrains, Neovim; suggestions appear as ghost text/inline as you type. Limitations to Keep in Mind Not always accurate: May generate syntax, logic, or performance errors.Solution: Always review, run lint/tests, and benchmark when needed.Security & copyright risks: Could resemble public code or leak if sensitive data is pasted.Solution: Enable “block suggestions matching public code,” avoid entering secrets, follow organizational policies.Risk of dependency: Over-reliance may weaken fundamental coding skills.Solution: Use Copilot for speed, but keep code reviews and tests.Limited domain knowledge: Suggestions may not fit specific business contexts.Solution: Break down requests, add examples/constraints, manually refine critical parts. Quick Start (VS Code) Install extensions: GitHub Copilot and (optional) GitHub Copilot Chat.Log in to GitHub and enable suggestions in Settings.Create a new file, describe requirements in Vietnamese/English within comments or docstrings.Press Tab to accept, Esc to skip. Check IDE shortcuts for more. Simple Examples Just comment your request, and GitHub Copilot will write code for you. Example 1: Utility function to validate email (JavaScript) // Write function isValidEmail(email: string): boolean function isValidEmail(email) { return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email); } Note: The regex above is basic — adjust according to project needs. Example 2: Quick API skeleton (Node.js/Express) // Create route GET /health that returns { status: 'ok' } app.get('/health', (req, res) => { res.json({ status: 'ok' }); }); Example 3: Basic unit test (Jest) // Write test for sum(a,b): 1+2=3, -1+1=0 test('sum basics', () => { expect(sum(1, 2)).toBe(3); expect(sum(-1, 1)).toBe(0); }); Tips for Using GitHub Copilot Effectively Write clear descriptions/comments: specify input, output, constraints, and examples.Always check & optimize code: run lint/tests, review performance, security.Break down complex requests: guide step by step for more accurate suggestions.Use Copilot Chat to research/explain, but always verify with original docs. Key Notes Enable “block suggestions matching public code” in organizational projects.Avoid pasting secrets (keys, credentials, sensitive data) into prompts. Conclusion GitHub Copilot is an AI assistant that helps you code faster, learn new tech quickly, and automate repetitive tasks — but you still need to review, test, and follow security policies. My Personal Experience Coding with GitHub Copilot Before using GitHub Copilot: Spent lots of time on repetitive, structured code.Slowed down by switching between coding and researching online. When first trying Copilot: Felt efficiency in simple features/functions.Struggled with complex features — Copilot often generated unnecessary code.Spent extra time reviewing Copilot’s output. After long-term use: Significantly reduced time on repetitive tasks (boilerplate, data mapping, simple CRUD, …).More consistent code (naming, structure), better documentation (docs, README) thanks to quick suggestions.Changed workflow: “comment-first” or “test-first” to guide Copilot, using Chat to refine and explain.Formed a risky habit: accepting Copilot’s suggestions too quickly without reviewing. Start Small & Measure Effectiveness Enable Copilot in your IDE, try with a utility function or basic test, turn on the “block public code” filter, and avoid pasting secrets. After one week, measure effectiveness (task completion time, amount of boilerplate written manually, number of minor bugs), then decide how much to apply in projects. Good luck using GitHub Copilot effectively — and may you achieve great success at the Hackathon!

            22/08/2025

            151

            Anh Nguyen T.

            Knowledge

            +0

              How Could You Join a Hackathon Without Knowing This?

              22/08/2025

              151

              Anh Nguyen T.

              CEO of SupremeTech Hackathon

              Our culture

              +0

                How a Hackathon Changed My Life – A Personal Story from the CEO of SupremeTech

                Written by Binh Nguyen, CEO of SupremeTech, from his own Hackathon journey Hi everyone,Today I’d like to share an experience that truly shaped who I am, not just as a professional, but as a builder. This is the story of how a Hackathon transformed my mindset from being just a developer into becoming a tech builder. Before moving into business analysis and later management, I started out as a Front-end Developer. Back in 2016, I was self-learning HTML, CSS, and React.js. Then in 2017, I had the chance to join a Hackathon that completely changed how I approached product development. It was the turning point that made me realize the difference between being a coder and being a builder. Step 1: Accepting the Challenge The Hackathon was organized by the Da Nang Business Incubator in collaboration with the Embassy of Israel, with support from venture capitalists and incubators from Israel. At that time, the prizes weren’t particularly big. But as someone new to the industry, eager to start a career and even dream of building a startup, I felt I had to join. Honestly, another reason was my competitive nature, I wanted to prove that even though I came from a non-tech background and had only been coding for a year, I could still stand shoulder-to-shoulder with others. Step 2: Preparing, Planning and Strategy For those unfamiliar, a Hackathon is a short, intensive coding competition where individuals or teams create a product in just a few days. You start from an idea, build it, and then present it on the last day - the demo day. The products are evaluated by the judges based on the Hackathon’s criteria. Our theme that year was straightforward: turn a startup idea into a product in just two days. If coding is a sport, then Hackathon is like a championship match. To build an app in such a short time, we had to prepare carefully, especially the methods to build a complete app as fast as possible. Boilerplates, bootstrap, pre-made components, even self-made code generation tools to save time… techniques that now are nothing difficult, but the goal of a Hackathon is always the same: build fast and ship immediately! With everything ready, we headed off to the competition. Step 3: Code, Bug, Hack and Chaos After the opening ceremony, we chose our topic and immediately got to work. Our topic was an app to find venues and make group reservations. Like most projects, the first 50% of the codebase went smoothly. We managed to build it within half a day. But the problems started when we moved into the core features and tricky logic like date pickers, slot reservations, venue data, etc. Ideas kept coming, we kept coding, and bugs showed up just as much. By 9 p.m., we were exhausted, buried in bugs, with no clear way forward, and nothing ready for the demo the next morning. So we decided to stop coding and discuss how to deliver on time. After more than an hour of debate, here’s how we planned the remaining work: Stop implementing backend logic and data crawlers, use front-end mockups to ensure demo flowDeploy on Heroku to save time on server setup and have a live productSpend extra time preparing slides to explain during the demo In the end, the chaos turned into something more organized. The funny part was that I, the front-end guy, had to keep coding, while our back-end guy ended up making the slides. Step 4: Demo – The G Hour After polishing things up until the last minute, we got on stage to demo. This part was quite similar to a sprint review, except that we had to stand on stage and present to a big audience. For everyone at ST now, sprint reviews are done very well already, so nothing more to add here. What surprised us was that the judges, especially the Israeli experts, didn’t pay much attention to the detailed features we had spent so much effort on. Instead, they asked “general” questions like: What is the technology that makes this product better than others?In what situations would users actually want to use this product? Step 5: Reflection – What I Gained We didn’t win for two main reasons: The software was quite complete but didn’t clearly show competitive advantages.Vietnamese users at that time didn’t really have the habit of booking tables/services via apps. Although we lost and felt quite upset at that moment, looking back now, I gained so much more: Confidence in setting up the initial codebase and preparing projects for productionUnderstanding that the value of technology lies in efficiency and competitiveness, not the number of featuresRealizing that users don’t care how much effort we put into building an app, they just want their problem solved in the best wayDelivering code fast and continuously, without waitingPreparation and choosing the right topic are the two keys to winningWith the right mindset, I could work with the best developers without losing confidence, even with less knowledge and experience Lastly: Try It Once—It Might Change You Too Hackathon changed me from being just a self-taught coder into a true tech builder. The mindset I gained in those two days has helped me a lot throughout my career until now. I believe many others will also learn valuable lessons from upcoming quality Hackathons. 100 million VND in prizes are waiting for you at the SupremeTech Hackathon this September 2025. Enjoy!

                21/08/2025

                168

                Binh Nguyen T.

                Our culture

                +0

                  How a Hackathon Changed My Life – A Personal Story from the CEO of SupremeTech

                  21/08/2025

                  168

                  Binh Nguyen T.

                  Customize software background

                  Want to customize a software for your business?

                  Meet with us! Schedule a meeting with us!