One idea/approach using bash and sed , you could try something like:

#!/usr/bin/env bash

while IFS='=' read -r prop_name prop_value; do
  if [[ "$prop_name" == "^"* ]]; then
     prop_name="\\${prop_name}"
  fi
  input_value+=("s/${prop_name}\\b/${prop_value}/g")
done < properties.txt

sed_input="$(IFS=';'; printf '%s' "${input_value[*]}")"

sed "$sed_input" sample_input.txt

One way to check the value of sed_input is

declare -p sed_input

Or

printf '%s\n' "$sed_input"

• Embedding an external utility from bash within a shell loop like cut and sed should be avoided. See why-is-using-a-shell-loop-to-process-text-considered-bad-practice

• The sed invocation above run only once even if the file that needs to be edited has 500+ lines.

• See How can I read a file (data stream, variable) line-by-line (and/or field-by-field)?

• See How can I use array variables in bash?

• See Parameter Expansion

• See Howto_Parameter_Expansion

• See How_do_I_do_string_manipulation_in_bash

Adding additional lines to OP's input file to demonstrate word boundary matching and a property name occurring more than once in a line:

$ cat input.txt
This is a story about $hello. It starts at a $foo and ends in a park.

Bob said to Sally "^hello, see you soon"

Leave first 2 matches alone: $foobar $hellow ^hello
^hello $foo $hello ^hello $foo $hello

Assumptions:

• for word boundary matching it is sufficient to verify the character immediately after a matching property name is not an alphabetic character ([a-zA-Z]); otherwise we can expand the next_char testing (see awk code, below)

General idea:

• read all properties.txt entries into an array (map[name]=value)
• for each line from input.txt, loop through all names, checking for any word boundary matches to replace

One idea using awk:

$ cat replace.awk

FNR==NR { split($0,arr,"=")                             # 1st file: split on "=" delimiter
          map[arr[1]]=arr[2]                            # build map[name]=value array, eg: map[$foo]=bar
          len[arr[1]]=length(arr[1])                    # save length of "name" so we do not have to repeatedly calculate later
          next
        }

NF      { newline = $0                                  # 2nd file: if we have at least one non white space field then make copy of current input line

          for (name in map) {                           # loop through all "names" to search for 
              line    = newline                         # start over copy of current line
              newline = ""

              while ( pos = index(line,name) ) {        # while we have a match ...

                    # find next_character after "name"; if it is an
                    # alpha/numeric character we do not have a word
                    # boundary otherwise we do have a word boundary
                    # and we need to make the replacement with 
                    # map[name]=value
                    
                    next_char = substr(line,pos+len[name],1)

                    if (next_char ~ /[[:alnum:]]/)
                       newline = newline substr(line,1,pos+len[name]-1)
                    else
                       newline = newline substr(line,1,pos-1) map[name]

                    line = substr(line,pos+len[name])   # strip off rest of line to test for additional matches of "name"
              }
              newline = newline line                    # append remaining contents of line
          }
          $0 = newline                                  # overwrite current input line with "newline"
        }
1                                                       # print current line

NOTES:

• most awk string matching functions (eg, sub(), gsub(), match()) treat the search pattern as a regex
• this means those non-alphabetic characters in OP's properties file (eg, $, ^) will need to be escaped before trying to use sub() / gsub() / match()
• instead of jumping through hoops to escape all special characters I've opted to use ...
• the index() function treats search patterns as literal text (so no need to escape special characters)

Taking for a test drive:

$ awk -f replace.awk properties.txt input.txt
This is a story about world. It starts at a bar and ends in a park.

Bob said to Sally "goodbye, see you soon"

Leave first 2 matches alone: $foobar $hellow goodbye
goodbye bar world goodbye bar world

For timing purposes I created a couple larger files from OP's properties file and my input.txt file (see above):

$ awk 'BEGIN {FS=OFS="="} {map[$1]=$2} END {for (i=1;i<=300;i++) {for (name in map) {nn=name x;print nn,map[name]};x++}}' properties.txt > properties.900.txt

$ for ((i=1;i<=250;i++)); do cat input.txt; done > input.1500.txt

$ wc -l properties.900.txt input.1500.txt
  900 properties.900.txt
 1500 input.1500.txt

Timing for the larger data files:

$ time awk -f replace.awk properties.900.txt input.1500.txt > output

real    0m0.126s
user    0m0.122s
sys     0m0.004s

$ head -12 output
This is a story about world. It starts at a bar and ends in a park.

Bob said to Sally "goodbye, see you soon"

Leave first 2 matches alone: $foobar $hellow goodbye
goodbye bar world goodbye bar world
This is a story about world. It starts at a bar and ends in a park.

Bob said to Sally "goodbye, see you soon"

Leave first 2 matches alone: $foobar $hellow goodbye
goodbye bar world goodbye bar world

NOTE: timing is from an Ubuntu 22.04 system (metal, vm) running on an Intel i7-1260P

What can I do to fix this?

Refactor your idea to write it in a single performant programming language. Bash is a shell - it executes other programs. Each program takes time to start.

You could generate sed script in one go and then execute it. Note that this will not handle ^hello or any other . * [ ? \ characters correctly, as sed works with regex. ^ matches beginning of a line.

sed "$(sed 's/\([^=]*\)=\(.*\)/s`\1\\b`\2`g/g' "$PROPERTIES_FILE")" "$INPUT_FILE"

You could escape the special characters with something along like this. See also https://stackoverflow.com/a/2705678/9072753 .

sed "$(sed 's/[]\/$*.^&[]/\\&/g; s/\([^=]*\)=\(.*\)/s`\1\\b`\2`g/g; ' "$PROPERTIES_FILE")" "$INPUT_FILE"

Notes: use shellcheck. Use $(...) instead of backticks. Do not abuse cats - just use <file instead of <<<$(cat "$PROPERTIES_FILE"). Don't SCREAM - consider lowercase variables. Consider m4, envsubst or jinja2 or just cpp for templating.

Your code seems to run in O(m.n) time looking for m possible properties in input of size n.

Since "both the properties file and the input files are hundreds/thousands of lines long", improving this to O(n) time may provide a noticeable speedup:

perl -e '
    # load mapping data into hash
    while ( ($k,$v) = split "=",<<>>,2 ) {
        chomp $v;
        $k2v{$k} = $v;
        last if eof;
    }

    # build regex from all keys (\Q escapes regex metacharacters)
    $re = join "|", map qr/\Q$_\E/, keys %k2v;

    # load input file as single string
    undef $/;
    $_ = <<>>;

    # convert all properties simultaneously
    s/($re)\b/ $k2v{$1} /ge;

    # output the result
    print;

' propfile inputfile

This makes use of a Perl regex optimisation that allows checking literal string alternations in constant, instead of linear, time.

I assume that recursive rewriting is not desired. For example, applying:

$key1=$key2
$key2=value

to blah $key1 should result in blah $key2 and not blah value

It may also be possible to process multiple inputfile in a loop so that the mapping data only needs to be loaded once, but it will be necessary to add some additional code to save each output instead of just writing to stdout.

I agree that this would be a lot more efficient in awk or perl or python, etc...

But to answer the question asked, yes, you can make this a lot more efficient with the tools you have. As mentioned, get rid of the time wasters. Your original code spawns unnecessary processes on practically every line.

Just have the code make one pass through the file to write all the individual sed substitution commands out to another script file (or accumulate them into a string as Jetchisel suggests) and then run that.

$ cat props
$foo=bar
$hello=world
^hello=goodbye

$ cat editme
This is a story about $hello. It starts at a $foo and ends in a park.

Bob said to Sally "^hello, see you soon"

$ cat editme.new
cat: editme.new: No such file or directory

$ cat script
#!/bin/bash
date +'Inital timestamp: %D %T %N' >&2
{ printf '%s\n' '#!/bin/bash' "time sed '"
  date +'Starting read of props file: %D %T %N' >&2
  while IFS='=' read -r k v;
  do printf '  s`%q\\b`%q`g;\n' "$k" "$v"
  done < props
  date +'Closing sed command: %D %T %N' >&2
  printf '%s\n' "' editme > editme.new"
} > editor
date +'Done writing sed script file: %D %T %N' >&2
cat editor
. editor

The two time outputs at the bottom are for the one run of sed and the whole script, respectively.

$ time ./script
Inital timestamp: 04/01/25 20:21:21 799559000
Starting read of props file: 04/01/25 20:21:21 812337100
Closing sed command: 04/01/25 20:21:21 824636300
Done writing sed script file: 04/01/25 20:21:21 837483000
#!/bin/bash
time sed '
  s`\$foo\b`bar`g;
  s`\$hello\b`world`g;
  s`\^hello\b`goodbye`g;
' editme > editme.new

real    0m0.014s
user    0m0.000s
sys     0m0.016s

real    0m0.104s
user    0m0.075s
sys     0m0.046s

and afterwards -

$ cat editme.new
This is a story about world. It starts at a bar and ends in a park.

Bob said to Sally "goodbye, see you soon"

addendum

Most bash scripts benefit a lot from moving subshells to built-ins.

A simplified version of my sed-based script above:

$ cat script
#!/bin/bash
{ printf '%s\n' '#!/bin/bash' "sed '"
  while IFS='=' read -r k v; do printf '  s`%q\\b`%q`g;\n' "$k" "$v"; done < props
  printf '%s\n' "' editme > editme.new"
} > editor
. editor

$ time ./script

real    0m0.043s
user    0m0.000s
sys     0m0.031s

Using simple bash string processing for the whole thing -

$ cat v2
#!/bin/bash
text="$(<editme)"
while IFS='=' read -r k v;
do while [[ "$text" =~ "$k" ]]; do text="${text//$k/$v}"; done
done < props
echo "$text" > editme.2

$ time ./v2

real    0m0.011s
user    0m0.015s
sys     0m0.000s

$ diff editme.new editme.2

This performs horribly on a large file, though, for a lot of reasons. I made a file of nearly 400MB and the sed script handled it in about 12.5s. I broke the all-in-memory all-bash version just under 3m.

Hmmm..... you write

INPUT=`cat $INPUT_FILE`  # you start a process here for cat.
while read line
do  
    PROP_NAME=`echo $line | cut -f1 -d'='`  # you start two processes here
    PROP_VALUE=`echo $line | cut -f2- -d'='`   # you start two processes here
    time INPUT="$(echo "$INPUT" | sed "s\`${PROP_NAME}\b\`${PROP_VALUE}\`g")" # two more processes
done <<<$(cat "$PROPERTIES_FILE")# Do more stuff with INPUT  # and one more here.

You don't specify the format of $INPUT_FILE or $PROPERTIES_FILE, so it's little help I can give you, but I suggest you to put everything in a single pipeline of commands, each making some process to the whole data set. Something like:

# this command generates substitution commands for all property name and value pairs
# in the form or `-e` commands for _sed(1)_ to make all substitutions in one shot.
# the pairs are in format VARIABLE = value  --->  -e 's"@VARIABLE@"value"g'
SED_PARAMETERS=$(
sed -E                                                                         \
    -e 's"^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$"-e '\''s\"@\1@\"\2\"g'\''"' \
    < "${PROPERTIES_FILE}" # first group is PROP_NAME, second is PROP_VALUE
)
# then, a sed command is run with this parameters on the input to produce a
# substitution made file
sed -E ${SED_PARAMETERS} < "${INPUT_FILE}" # outputs the transformed file to stdout.
    

This way, only two programs are run:

1. sed is run on the properties file to generate a set of -e s"@param_name@"param_value"g parameters (according to what is read from the parameters file) to be used in a single run of the input file to change all parameters in one shot.

2. another set is run with the parameters above, to change all ocurrences of @parameter_name@ to parameter_value output is to stdout, so you can chain it an pipe to another file.

if you let this on a shell script and use stdin to feed the second sed(1) command, then you can make parameter substitution on the fly. I use this approach to put all configuration parameters in a config.mk file, that is parsed to generate the Makefile configurables, the source code configurables and the documentation configurables in a single file.