Author Archive for: admin

Original Source: https://www.creativebloq.com/creative-inspiration/digital-crafting/ive-never-been-more-tempted-to-buy-a-cricut-explore-air-2-now-only-gbp199

This counts as a necessary wedding expense, right?

Original Source: https://smashingmagazine.com/2024/12/mastering-svg-arcs/

So, I love drawing birds with code. Inspired by my brother’s love for birdwatching, I admire the uniqueness of their feathers, colors, and sounds. But what I notice most is the way their bodies curve and different birds can have dramatically different curves! So, I took my love for drawing with SVG graphics and used it to experiment with bird shapes. Over time, I’ve drawn enough to become incredibly adept at working with arc shapes.

Here are a few of my recent works. Inspired by designs I came across on Dribbble, I created my versions with code. You can browse through the code for each on my CodePen.

But before we dive into creating curves with arcs, please pause here and check out Myriam Frisano’s recent article, “SVG Coding Examples: Useful Recipes For Writing Vectors By Hand.” It’s an excellent primer to the SVG syntax and it will give you solid context heading into the concepts we’re covering here when it comes to mastering SVG arcs.

A Quick SVG Refresher

You probably know that SVGs are crisp, infinitely scalable illustrations without pixelated degradation — vectors for the win! What you might not know is that few developers write SVG code. Why? Well, the syntax looks complicated and unfamiliar compared to, say, HTML. But trust me, once you break it down, it’s not only possible to hand-code SVG but also quite a bit of fun.

Let’s make sure you’re up to speed on the SVG viewBox because it’s a key concept when it comes to the scalable part of *SVG. We’ll use the analogy of a camera, lens, and canvas to explain this concept. Think of your browser window as a camera and the SVG viewBox as the camera lens focusing on the painting of a bird you’ve created (the SVG). Imagine the painting on a large canvas that may stretch far beyond what the camera captures. The viewBox defines which part of this canvas is visible through the camera.

Let’s say we have an SVG element that we’re sizing at 600px square with width and height attributes directly on the <svg> element.

<svg width=”600px” height=”600px”>

Let’s turn our attention to the viewBox attribute:

<svg width=”600px” height=”600px” viewBox=”-300 -300 600 600″>

The viewBox attribute defines the internal coordinate system for the SVG, with four values mapping to the SVG’s x, y, width, and height in that order.

Here’s how this relates to our analogy:

Camera Position and Size
The -300, -300 represents the camera lens’ left and top edge position. Meanwhile, 600 x 600 is like the camera’s frame size, showing a specific portion of that space.
Unchanging Canvas Size
Changing the x and y values adjusts where the camera points, and width and height govern how much of the canvas it frames. It doesn’t resize the actual canvas (the SVG element itself, which remains at 600×600 pixels). No matter where the camera is positioned or zoomed, the canvas itself remains fixed.

So, when you adjust the viewBox coordinates, you’re simply choosing a new area of the canvas to focus on without resizing the canvas itself. This lets you control the visible area without changing the SVG’s actual display dimensions.

You now have the context you need to learn how to work with <path> elements in SVG, which is where we start working with arcs!

The <path> Element

We have an <svg> element. And we’re viewing the element’s contents through the “lens” of a viewBox.

A <path> allows us to draw shapes. We have other elements for drawing shapes — namely <circle>, <line>, and <polygon> — but imagine being restricted to strict geometrical shapes as an artist. That’s where the custom <path> element comes in. It’s used to draw complex shapes that cannot be created with the basic ones. Think of <path> as a flexible container that lets you mix and match different drawing commands.

With a single <path>, you can combine multiple drawing commands into one smooth, elegant design. Today, we’re focusing on a super specific path command: arcs. In other words, what we’re doing is drawing arc shapes with <path>.

Here’s a quick, no-frills example that places a <path> inside the <svg> example we looked at earlier:

<svg width=”600px” height=”600px” viewBox=”-300 -300 600 600″>
<path d=”M 0 0 A 100 100 0 1 1 200 0″
fill=”transparent”
stroke=”black”
stroke-width=”24″
/>
</svg>

Let’s take this information and start playing with values to see how it behaves.

Visualizing The Possibilities

Again, if this is the <path> we’re starting with:

<path d=”M 0 0 A 100 100 0 1 1 200 0″/>

Then, we can manipulate it in myriad ways. Mathematically speaking, you can create an infinite number of arcs between any two points by adjusting the parameters. Here are a few variations of an arc that we get when all we do is change the arc’s endpoints in the X (<ex>) and Y (<ey>) directions.

See the Pen Arc Possibilities b/w 2 points [forked] by akshaygpt.

Or, let’s control the arc’s width and height by updating its radius in the X direction (<rx>) and the Y direction (<ry>). If we play around with the <rx> value, we can manipulate the arc’s height:

See the Pen Rx [forked] by akshaygpt.

Similarly, we can manipulate the arc’s width by updating the <ry> value:

See the Pen Rx [forked] by akshaygpt.

Let’s see what happens when we rotate the arc along its X-axis (<rotation>). This parameter rotates the arc’s ellipse around its center. It won’t affect circles, but it’s a game-changer for ellipses.

See the Pen x-axis-rotation [forked] by akshaygpt.

Even with a fixed set of endpoints and radii (<rx> and <ry>), and a given angle of rotation, four distinct arcs can connect them. That’s because we have the <arc> flag value that can be one of two values, as well as the <sweep> flag that is also one of two values. Two boolean values, each with two arguments, give us four distinct possibilities.

See the Pen 4 cases [forked] by akshaygpt.

And lastly, adjusting the arc’s endpoint along the X (<ex>) and Y (<ey>) directions shifts the arc’s location without changing the overall shape.

See the Pen endx, endy [forked] by akshaygpt.

Wrapping Up

And there you have it, SVG arcs demystified! Whether you’re manipulating radii, rotation, or arc direction, you now have all the tools to master these beautiful curves. With practice, arcs will become just another part of your SVG toolkit, one that gives you the power to create more dynamic, intricate designs with confidence.

So keep playing, keep experimenting, and soon you’ll be bending arcs like a pro — making your SVGs not just functional but beautifully artistic. If you enjoyed this dive into arcs, drop a like or share it with your friends. Let’s keep pushing the boundaries of what SVG can do!

Original Source: https://tympanus.net/codrops/2024/12/09/creating-the-morphing-effect-of-the-luma-dream-machine-website/

Learn how to create this powerful morphing effect with only JavaScript using the Canvas2D API.

Original Source: https://www.hongkiat.com/blog/simple-free-resume-tools/

Why does everyone need a different resume? Because no single version works for all jobs. Each opportunity demands a unique approach. But what do most people do? They grab a basic template, tweak it a bit, and end up with a dull, one-size-fits-all resume. That doesn’t cut it – especially when you’re trying to stand out in a competitive job market.

If you want a resume that highlights your skills and fits perfectly with a specific job or industry, you’re in luck. There are some excellent free tools available that can help. These tools offer templates, guidance, and customization options to create a professional resume without the hassle. Let’s explore 15 of the best free tools to help you build a resume that’s ready to impress.

30 Free Beautiful Resume Templates to Download

.no-js #ref-block-post-23761 .ref-block__thumbnail { background-image: url(“https://assets.hongkiat.com/uploads/thumbs/250×160/editable-resume-template.jpg”); }

30 Free Beautiful Resume Templates to Download

You probably have seen the professional-looking, eye-catching resumes that talented web designers have been designing and showcasing online…. Read more

Freepik Resume Builder

For those who want to wow potential employers with an eye-catching and memorable resume, Freepik’s Resume Builder and its vast selection of professionally designed resume templates is the tool for you. Every aspect of the design is customizable thanks to its unique template editor, allowing users to replace images and alter text easily.

Users can also take advantage of its integrated AI writer, an automated writing tool that can polish and refine text to a high standard. Once happy, you can download the document as a PDF, the standard for most CVs, or as an image, selecting JPEG or PNG.

Visit Freepik Resume Builder

CV Wizard

CV Wizard (formerly known as CV Maker) is a multilingual tool for building a professional resume. What impressed me is, you can choose from a wide range of pre-designed templates per your profession. You do not need to format or arrange the layouts manually – all is already done for you.

Also, you can arrange the sections per your requirement. Another interesting feature is you can host your resume on this site and share its link with anyone. Also, you can export the resume in PDF, HTML, or TXT format. Last but not the least, this platform comes with a simple interface that helps beginners to create an awesome resume seamlessly.

Visit CV Wizard

ResumeGiants

ResumeGiants is a resume building tool you can use to make things easier during a job search. It offers a step-by-step guide to design and build an amazing looking resume that gets the results.

The platform offers hundreds of professional resume templates to choose from. And if you think that your chosen template could use some extra sections, or a complete redesign, you can easily make these changes – all without having to start from scratch.

ResumeGiants is a free service and works with filtering software like applicant tracking systems (ATS) to give you the extra support necessary to get the best jobs available.

Visit ResumeGiants

ResumeCoach

ResumeCoach features everything that you need from a professional resume maker. On the basis of an array of templates, you can create a stunning resume tailored to your requirements in a few simple steps.

At each step of the resume creation process, ResumeCoach guides you with tips and examples that help you make your document interesting and ideal for the particular industry that you’re applying for.

Moreover, the resume templates available on the site are categorized into student resume, entry-level resume, or professional resume so you can pick the one for your particular needs. There are also resumes from different professional fields like graphic designer, nurse, teacher, or customer service professional, etc.

Visit ResumeCoach

VisualCV

Visual CV lets you choose a handsome yet professional design and build a dynamic web portfolio or a professional resume out of it. The tool, unlike CV Maker, lets you create custom versions of your resume having similar or different formats. That means you can create multiple resumes for different job opportunities and present your best in them.

Moreover, you can create different versions of your resume where a new version is better than the old one. This feature helps in comparing and improving your resume. As a result, the resulting resume looks distinguished and well-polished. When you are done, you can export it to a PDF.

Visit VisualCV

Resume.com

Resume.com is a free resume builder that lets you create, edit, and build a perfect resume, thanks to its user-friendly resume builder. This tool allows you to fetch your details from Facebook and LinkedIn so you can fill your resume quick and easy.

Resume.com can build a job-specific resume with its wide range of brilliant templates. Amazingly, the resume can also be shared with others, like CV Maker. Last but not the least, you can create multiple versions of your resume for applying for different openings.

Visit Resume.com

Resume Builder

Resume Builder lets you create powerful resumes with step by step instructions. What surprised me is that this tool provides pre-written job-specific sample phrases and punchlines that are created by experts to help people nail jobs. I also like its dozens of resume template designs, which helps building awesome resumes.

You can create, download, and print the resume, and use formatting tools to customize it to showcase your creativity. Resume Builder can be started free of cost like others above, and it also helps to share and promote your resume through social networks.

Visit Resume Builder

DoYouBuzz

DoYouBuzz allows building resumes in web and mobile formats. As with others, you do not need to worry about the layout because its resume template does this job for you. You can choose the content you would like to add in the form fields, and your resume will be built.

You can get feedback from others before finalizing the resume. Your resume is shareable so that you can promote it on social networks. Also, you can opt to show your resume on Google, just like any public site or page appears on it. Last but not the least, the resume can even be downloaded and printed out easily.

Visit DoYouBuzz

Resumonk

Resumonk is a premium resume builder that can generate the resume in PDF and DOCX formats. You can choose from a large range of resume templates, fill in your information, and build your resume easily and quickly. The tool lets you create unlimited resumes, but with its free edition, you can avail just a limited number of templates.

What differentiates this tool from the others is, it offers ‘Photo CV’ templates that allow adding your professional pic to the resume. Interestingly, you can even import details from LinkedIn, like Resume.com, and share your resume with others by sharing its URL. You can also create a cover letter for each resume, but this is limited to its premium pack.

Visit Resumonk

ResumeGenius

ResumeGenius is one of the fastest resume builders that can create a professional resume without requiring any writing skills. It helps create your resume with its ‘point, click, and create’ method that simplifies creating resumes. Also, the templates provided by ResumeGenius are software-friendly and help you to not get unrecognized by such tools.

You can choose from over 20+ professional templates and 50k+ phrases for different form fields. That means you can create an impressive resume even if you don’t have a good command on English language. You can also download your resume in PDF, DOCX, and TXT formats and can create an unlimited number of resumes, however with the premium subscription.

Visit ResumeGenius

Kickresume

KickResume offers a wide range of resume and cover letter templates that you can customize your resume with custom colors, icons, and layouts, resulting in a customized resume. Moreover, you can create a personal resume website with its premium subscription.

Contrary to some above-mentioned tools, KickResume’s free version allows limited entries and categories and just the basic resume templates. Moreover, though you can download your resume yet it does not offer any social sharing features like few others. However, its templates support tracking system, so you can be sure you are not missed out.

Visit Kickresume

Novorèsumè

Unlike the other tools, Novorèsumè focuses more on the content than the design to helps you improve the resume. It contains a content optimizer that analyzes your resume content and suggests possible revisions to make it even better. Moreover, you can optimize and customize the resume layout and preview it in live mode.

You can create your resume in multiple languages, as you can do with CV Maker. The free version of the tool allows you to build a one-page resume with predefined layouts. However, unlike few above tools, it does not provide pre-written phrases. After you are done creating your resume, you can download it as PDF, or share it with others.

Visit Novorèsumè

Resume Companion

Resume Companion provides approved, professional resume as well as cover letter templates with thousands of content options. The tool offers about 5k+ pre-written content phrases, which you can insert with just one click.

You will find many resume sections, and you can arrange them per your requirement. Also, the tool automatically formats the resume for you, after which, the final resume can be exported to a Word or a PDF document. However, it lacks resume hosting and social sharing features that are offered by few of the above tools.

Visit Resume Companion

HipCV

HipCV offers professional CV designs and layouts, and also professionally-written phrases and sentences for creating awesome first impressions. The tool is completely free to use, and there’s no limit on the number of resumes, unlike some others.

You can download the CV in PDF format or email it to apply directly. You can also get a link to your resume hosted on its site, and share the same on social media platforms. And what more interestingly is that HipCV tracks the number of visits on your CV, so you always know the traffic arriving to check out your resume – same as Google Analytics work.

Visit HipCV

The post 15 Free Tools to Create Professional Resumes appeared first on Hongkiat.

Original Source: https://smashingmagazine.com/2024/12/creating-effective-multistep-form-better-user-experience/

For a multistep form, planning involves structuring questions logically across steps, grouping similar questions, and minimizing the number of steps and the amount of required information for each step. Whatever makes each step focused and manageable is what should be aimed for.

In this tutorial, we will create a multistep form for a job application. Here are the details we are going to be requesting from the applicant at each step:

Personal Information
Collects applicant’s name, email, and phone number.
Work Experience
Collects the applicant’s most recent company, job title, and years of experience.
Skills & Qualifications
The applicant lists their skills and selects their highest degree.
Review & Submit
This step is not going to collect any information. Instead, it provides an opportunity for the applicant to go back and review the information entered in the previous steps of the form before submitting it.

You can think of structuring these questions as a digital way of getting to know somebody. You can’t meet someone for the first time and ask them about their work experience without first asking for their name.

Based on the steps we have above, this is what the body of our HTML with our form should look like. First, the main <form> element:

<form id=”jobApplicationForm”>
<!– Step 1: Personal Information –>
<!– Step 2: Work Experience –>
<!– Step 3: Skills & Qualifications –>
<!– Step 4: Review & Submit –>
</form>

Step 1 is for filling in personal information, like the applicant’s name, email address, and phone number:

<form id=”jobApplicationForm”>
<!– Step 1: Personal Information –>
<fieldset class=”step” id=”step-1″>
<legend id=”step1Label”>Step 1: Personal Information</legend>
<label for=”name”>Full Name</label>
<input type=”text” id=”name” name=”name” required />
<label for=”email”>Email Address</label>
<input type=”email” id=”email” name=”email” required />
<label for=”phone”>Phone Number</label>
<input type=”tel” id=”phone” name=”phone” required />
</fieldset>

<!– Step 2: Work Experience –>
<!– Step 3: Skills & Qualifications –>
<!– Step 4: Review & Submit –>
</form>

Once the applicant completes the first step, we’ll navigate them to Step 2, focusing on their work experience so that we can collect information like their most recent company, job title, and years of experience. We’ll tack on a new <fieldset> with those inputs:

<form id=”jobApplicationForm”>
<!– Step 1: Personal Information –>

<!– Step 2: Work Experience –>
<fieldset class=”step” id=”step-2″ hidden>
<legend id=”step2Label”>Step 2: Work Experience</legend>
<label for=”company”>Most Recent Company</label>
<input type=”text” id=”company” name=”company” required />
<label for=”jobTitle”>Job Title</label>
<input type=”text” id=”jobTitle” name=”jobTitle” required />
<label for=”yearsExperience”>Years of Experience</label>
<input
type=”number”
id=”yearsExperience”
name=”yearsExperience”
min=”0″
required
/>
</fieldset>

<!– Step 3: Skills & Qualifications –>
<!– Step 4: Review & Submit –>
</form>

Step 3 is all about the applicant listing their skills and qualifications for the job they’re applying for:

<form id=”jobApplicationForm”>
<!– Step 1: Personal Information –>
<!– Step 2: Work Experience –>

<!– Step 3: Skills & Qualifications –>
<fieldset class=”step” id=”step-3″ hidden>
<legend id=”step3Label”>Step 3: Skills & Qualifications</legend>
<label for=”skills”>Skill(s)</label>
<textarea id=”skills” name=”skills” rows=”4″ required></textarea>
<label for=”highestDegree”>Degree Obtained (Highest)</label>
<select id=”highestDegree” name=”highestDegree” required>
<option value=””>Select Degree</option>
<option value=”highschool”>High School Diploma</option>
<option value=”bachelor”>Bachelor’s Degree</option>
<option value=”master”>Master’s Degree</option>
<option value=”phd”>Ph.D.</option>
</select>
</fieldset>
<!– Step 4: Review & Submit –>
<fieldset class=”step” id=”step-4″ hidden>
<legend id=”step4Label”>Step 4: Review & Submit</legend>
<p>Review your information before submitting the application.</p>
<button type=”submit”>Submit Application</button>
</fieldset>
</form>

And, finally, we’ll allow the applicant to review their information before submitting it:

<form id=”jobApplicationForm”>
<!– Step 1: Personal Information –>
<!– Step 2: Work Experience –>
<!– Step 3: Skills & Qualifications –>

<!– Step 4: Review & Submit –>
<fieldset class=”step” id=”step-4″ hidden>
<legend id=”step4Label”>Step 4: Review & Submit</legend>
<p>Review your information before submitting the application.</p>
<button type=”submit”>Submit Application</button>
</fieldset>
</form>

Notice: We’ve added a hidden attribute to every fieldset element but the first one. This ensures that the user sees only the first step. Once they are done with the first step, they can proceed to fill out their work experience on the second step by clicking a navigational button. We’ll add this button later on.

Adding Styles

To keep things focused, we’re not going to be emphasizing the styles in this tutorial. What we’ll do to keep things simple is leverage the Simple.css style framework to get the form in good shape for the rest of the tutorial.

If you’re following along, we can include Simple’s styles in the document <head>:

<link rel=”stylesheet” href=”https://cdn.simplecss.org/simple.min.css” />

And from there, go ahead and create a style.css file with the following styles that I’ve folded up.

<details>
<summary>View CSS</summary>
body {
min-height: 100vh;
display: flex;
align-items: center;
justify-content: center;
}
main {
padding: 0 30px;
}
h1 {
font-size: 1.8rem;
text-align: center;
}
.stepper {
display: flex;
justify-content: flex-end;
padding-right: 10px;
}
form {
box-shadow: 0px 0px 6px 2px rgba(0, 0, 0, 0.2);
padding: 12px;
}
input,
textarea,
select {
outline: none;
}
input:valid,
textarea:valid,
select:valid,
input:focus:valid,
textarea:focus:valid,
select:focus:valid {
border-color: green;
}
input:focus:invalid,
textarea:focus:invalid,
select:focus:invalid {
border: 1px solid red;
}
</details>

Form Navigation And Validation

An easy way to ruin the user experience for a multi-step form is to wait until the user gets to the last step in the form before letting them know of any error they made along the way. Each step of the form should be validated for errors before moving on to the next step, and descriptive error messages should be displayed to enable users to understand what is wrong and how to fix it.

Now, the only part of our form that is visible is the first step. To complete the form, users need to be able to navigate to the other steps. We are going to use several buttons to pull this off. The first step is going to have a Next button. The second and third steps are going to have both a Previous and a Next button, and the fourth step is going to have a Previous and a Submit button.

<form id=”jobApplicationForm”>
<!– Step 1: Personal Information –>
<fieldset>
<!– … –>
<button type=”button” class=”next” onclick=”nextStep()”>Next</button>
</fieldset>

<!– Step 2: Work Experience –>
<fieldset>
<!– … –>
<button type=”button” class=”previous” onclick=”previousStep()”>Previous</button>
<button type=”button” class=”next” onclick=”nextStep()”>Next</button>
</fieldset>

<!– Step 3: Skills & Qualifications –>
<fieldset>
<!– … –>
<button type=”button” class=”previous” onclick=”previousStep()”>Previous</button>
<button type=”button” class=”next” onclick=”nextStep()”>Next</button>
</fieldset>

<!– Step 4: Review & Submit –>
<fieldset>
<!– … –>
<button type=”button” class=”previous” onclick=”previousStep()”>Previous</button>
<button type=”submit”>Submit Application</button>
</fieldset>
</form>

Notice: We’ve added onclick attributes to the Previous and Next buttons to link them to their respective JavaScript functions: previousStep() and nextStep().

The “Next” Button

The nextStep() function is linked to the Next button. Whenever the user clicks the Next button, the nextStep() function will first check to ensure that all the fields for whatever step the user is on have been filled out correctly before moving on to the next step. If the fields haven’t been filled correctly, it displays some error messages, letting the user know that they’ve done something wrong and informing them what to do to make the errors go away.

Before we go into the implementation of the nextStep function, there are certain variables we need to define because they will be needed in the function. First, we need the input fields from the DOM so we can run checks on them to make sure they are valid.

// Step 1 fields
const name = document.getElementById(“name”);
const email = document.getElementById(“email”);
const phone = document.getElementById(“phone”);

// Step 2 fields
const company = document.getElementById(“company”);
const jobTitle = document.getElementById(“jobTitle”);
const yearsExperience = document.getElementById(“yearsExperience”);

// Step 3 fields
const skills = document.getElementById(“skills”);
const highestDegree = document.getElementById(“highestDegree”);

Then, we’re going to need an array to store our error messages.

let errorMsgs = [];

Also, we would need an element in the DOM where we can insert those error messages after they’ve been generated. This element should be placed in the HTML just below the last fieldset closing tag:

<div id=”errorMessages” style=”color: rgb(253, 67, 67)”></div>

Add the above div to the JavaScript code using the following line:

const errorMessagesDiv = document.getElementById(“errorMessages”);

And finally, we need a variable to keep track of the current step.

let currentStep = 1;

Now that we have all our variables in place, here’s the implementation of the nextstep() function:

function nextStep() {
errorMsgs = [];
errorMessagesDiv.innerText = “”;

switch (currentStep) {
case 1:
addValidationErrors(name, email, phone);
validateStep(errorMsgs);
break;

case 2:
addValidationErrors(company, jobTitle, yearsExperience);
validateStep(errorMsgs);
break;

case 3:
addValidationErrors(skills, highestDegree);
validateStep(errorMsgs);
break;
}
}

The moment the Next button is pressed, our code first checks which step the user is currently on, and based on this information, it validates the data for that specific step by calling the addValidationErrors() function. If there are errors, we display them. Then, the form calls the validateStep() function to verify that there are no errors before moving on to the next step. If there are errors, it prevents the user from going on to the next step.

Whenever the nextStep() function runs, the error messages are cleared first to avoid appending errors from a different step to existing errors or re-adding existing error messages when the addValidationErrors function runs. The addValidationErrors function is called for each step using the fields for that step as arguments.

Here’s how the addValidationErrors function is implemented:

function addValidationErrors(fieldOne, fieldTwo, fieldThree = undefined) {
if (!fieldOne.checkValidity()) {
const label = document.querySelector(label[for=”${fieldOne.id}”]);
errorMsgs.push(Please Enter A Valid ${label.textContent});
}

if (!fieldTwo.checkValidity()) {
const label = document.querySelector(label[for=”${fieldTwo.id}”]);
errorMsgs.push(Please Enter A Valid ${label.textContent});
}

if (fieldThree && !fieldThree.checkValidity()) {
const label = document.querySelector(label[for=”${fieldThree.id}”]);
errorMsgs.push(Please Enter A Valid ${label.textContent});
}

if (errorMsgs.length > 0) {
errorMessagesDiv.innerText = errorMsgs.join(“n”);
}
}

This is how the validateStep() function is defined:

function validateStep(errorMsgs) {
if (errorMsgs.length === 0) {
showStep(currentStep + 1);
}
}

The validateStep() function checks for errors. If there are none, it proceeds to the next step with the help of the showStep() function.

function showStep(step) {
steps.forEach((el, index) => {
el.hidden = index + 1 !== step;
});
currentStep = step;
}

The showStep() function requires the four fieldsets in the DOM. Add the following line to the top of the JavaScript code to make the fieldsets available:

const steps = document.querySelectorAll(“.step”);

What the showStep() function does is to go through all the fieldsets in our form and hide whatever fieldset is not equal to the one we’re navigating to. Then, it updates the currentStep variable to be equal to the step we’re navigating to.

The “Previous” Button

The previousStep() function is linked to the Previous button. Whenever the previous button is clicked, similarly to the nextStep function, the error messages are also cleared from the page, and navigation is also handled by the showStep function.

function previousStep() {
errorMessagesDiv.innerText = “”;
showStep(currentStep – 1);
}

Whenever the showStep() function is called with “currentStep – 1” as an argument (as in this case), we go back to the previous step, while moving to the next step happens by calling the showStep() function with “currentStep + 1″ as an argument (as in the case of the validateStep() function).

Improving User Experience With Visual Cues

One other way of improving the user experience for a multi-step form, is by integrating visual cues, things that will give users feedback on the process they are on. These things can include a progress indicator or a stepper to help the user know the exact step they are on.

Integrating A Stepper

To integrate a stepper into our form (sort of like this one from Material Design), the first thing we need to do is add it to the HTML just below the opening <form> tag.

<form id=”jobApplicationForm”>
<div class=”stepper”>
<span><span class=”currentStep”>1</span>/4</span>
</div>
<!– … –>
</form>

Next, we need to query the part of the stepper that will represent the current step. This is the span tag with the class name of currentStep.

const currentStepDiv = document.querySelector(“.currentStep”);

Now, we need to update the stepper value whenever the previous or next buttons are clicked. To do this, we need to update the showStep() function by appending the following line to it:

currentStepDiv.innerText = currentStep;

This line is added to the showStep() function because the showStep() function is responsible for navigating between steps and updating the currentStep variable. So, whenever the currentStep variable is updated, the currentStepDiv should also be updated to reflect that change.

Storing And Retrieving User Data

One major way we can improve the form’s user experience is by storing user data in the browser. Multistep forms are usually long and require users to enter a lot of information about themselves. Imagine a user filling out 95% of a form, then accidentally hitting the F5 button on their keyboard and losing all their progress. That would be a really bad experience for the user.

Using localStorage, we can store user information as soon as it is entered and retrieve it as soon as the DOM content is loaded, so users can always continue filling out their forms from wherever they left off. To add this feature to our forms, we can begin by saving the user’s information as soon as it is typed. This can be achieved using the input event.

Before adding the input event listener, get the form element from the DOM:

const form = document.getElementById(“jobApplicationForm”);

Now we can add the input event listener:

// Save data on each input event
form.addEventListener(“input”, () => {
const formData = {
name: document.getElementById(“name”).value,
email: document.getElementById(“email”).value,
phone: document.getElementById(“phone”).value,
company: document.getElementById(“company”).value,
jobTitle: document.getElementById(“jobTitle”).value,
yearsExperience: document.getElementById(“yearsExperience”).value,
skills: document.getElementById(“skills”).value,
highestDegree: document.getElementById(“highestDegree”).value,
};
localStorage.setItem(“formData”, JSON.stringify(formData));
});

Next, we need to add some code to help us retrieve the user data once the DOM content is loaded.

window.addEventListener(“DOMContentLoaded”, () => {
const savedData = JSON.parse(localStorage.getItem(“formData”));
if (savedData) {
document.getElementById(“name”).value = savedData.name || “”;
document.getElementById(“email”).value = savedData.email || “”;
document.getElementById(“phone”).value = savedData.phone || “”;
document.getElementById(“company”).value = savedData.company || “”;
document.getElementById(“jobTitle”).value = savedData.jobTitle || “”;
document.getElementById(“yearsExperience”).value = savedData.yearsExperience || “”;
document.getElementById(“skills”).value = savedData.skills || “”;
document.getElementById(“highestDegree”).value = savedData.highestDegree || “”;
}
});

Lastly, it is good practice to remove data from localStorage as soon as it is no longer needed:

// Clear data on form submit
form.addEventListener(‘submit’, () => {
// Clear localStorage once the form is submitted
localStorage.removeItem(‘formData’);
});

Adding The Current Step Value To localStorage

If the user accidentally closes their browser, they should be able to return to wherever they left off. This means that the current step value also has to be saved in localStorage.

To save this value, append the following line to the showStep() function:

localStorage.setItem(“storedStep”, currentStep);

Now we can retrieve the current step value and return users to wherever they left off whenever the DOM content loads. Add the following code to the DOMContentLoaded handler to do so:

const storedStep = localStorage.getItem(“storedStep”);

if (storedStep) {
const storedStepInt = parseInt(storedStep);
steps.forEach((el, index) => {
el.hidden = index + 1 !== storedStepInt;
});
currentStep = storedStepInt;
currentStepDiv.innerText = currentStep;
}

Also, do not forget to clear the current step value from localStorage when the form is submitted.

localStorage.removeItem(“storedStep”);

The above line should be added to the submit handler.

Wrapping Up

Creating multi-step forms can help improve user experience for complex data entry. By carefully planning out steps, implementing form validation at each step, and temporarily storing user data in the browser, you make it easier for users to complete long forms.

For the full implementation of this multi-step form, you can access the complete code on GitHub.